Fonctions & Typage

// Paramètres typés + retour typé
function additionner(a: number, b: number): number {
  return a + b
}

additionner(5, 3)        // ✅ 8
// additionner("5", 3)   // ❌ Le premier argument doit être un number

// Arrow function typée
const multiplier = (a: number, b: number): number => a * b

// Le retour est souvent inféré, mais l'annoter est une bonne pratique
function saluer(nom: string) {  // retour inféré : string
  return `Bonjour ${nom}`
}

// Paramètre optionnel avec "?"
function creerProfil(nom: string, bio?: string): string {
  if (bio) {
    return `${nom} - ${bio}`
  }
  return nom
}

creerProfil("Alice")                 // ✅ "Alice"
creerProfil("Alice", "Dev TypeScript")  // ✅ "Alice - Dev TypeScript"

// Paramètre avec valeur par défaut
function creerMessage(texte: string, auteur: string = "Anonyme"): string {
  return `${auteur} dit : ${texte}`
}

creerMessage("Salut !")              // ✅ "Anonyme dit : Salut !"
creerMessage("Salut !", "Bob")       // ✅ "Bob dit : Salut !"

// ⚠️ Les optionnels viennent APRÈS les obligatoires
// function bad(a?: string, b: number) {}  // ❌ Pas logique

// Nombre variable d'arguments
function somme(...nombres: number[]): number {
  return nombres.reduce((total, n) => total + n, 0)
}

somme(1, 2, 3)          // ✅ 6
somme(10, 20, 30, 40)   // ✅ 100

// Combiner avec des paramètres fixes
function logAction(action: string, ...details: string[]): void {
  console.log(`[${action}] ${details.join(", ")}`)
}

logAction("SAVE", "fichier.ts", "ligne 42", "auto-save")

// Type d'une fonction
type Operation = (a: number, b: number) => number

const addition: Operation = (a, b) => a + b
const soustraction: Operation = (a, b) => a - b

// Très utile pour les callbacks
function appliquer(x: number, y: number, fn: Operation): number {
  return fn(x, y)
}

appliquer(10, 5, addition)      // 15
appliquer(10, 5, soustraction)  // 5

// Callback typé inline
function filtrer(
  tableau: number[],
  condition: (n: number) => boolean
): number[] {
  return tableau.filter(condition)
}

filtrer([1, 2, 3, 4, 5], n => n > 3)  // [4, 5]

// Signatures de surcharge
function formater(valeur: string): string
function formater(valeur: number): string
function formater(valeur: string | number): string {
  if (typeof valeur === "string") {
    return valeur.toUpperCase()
  }
  return valeur.toFixed(2)
}

formater("bonjour")  // "BONJOUR" - retour string
formater(3.14159)    // "3.14"    - retour string

// Exemple plus concret
function chercher(id: number): Utilisateur
function chercher(email: string): Utilisateur
function chercher(critere: number | string): Utilisateur {
  if (typeof critere === "number") {
    return trouverParId(critere)
  }
  return trouverParEmail(critere)
}

// Sans générique : perte d'information
function premier(tableau: any[]): any {
  return tableau[0]
}
// On ne sait pas quel type est retourné...

// Avec générique : le type est préservé
function premierElement<T>(tableau: T[]): T {
  return tableau[0]
}

premierElement([1, 2, 3])           // type retourné: number
premierElement(["a", "b", "c"])     // type retourné: string
premierElement([true, false])       // type retourné: boolean

// TypeScript infère automatiquement le T
// Mais tu peux le préciser :
premierElement<string>(["hello"])   // type retourné: string

// Parfois tu en sais plus que TypeScript
const input = document.getElementById("email") as HTMLInputElement
input.value = "alice@email.com"  // ✅ Sans "as", TS ne saurait pas que c'est un input

// Syntaxe alternative (pas en JSX)
const button = <HTMLButtonElement>document.getElementById("btn")

// ⚠️ L'assertion ne fait AUCUNE vérification au runtime
// C'est une promesse que tu fais à TypeScript
const donnees = JSON.parse('{"nom": "Alice"}') as { nom: string }
// Si le JSON n'a pas cette forme, crash au runtime !