⚡ Typage des fonctions

// Annotations de paramètres et de retour
function greet(name: string, title?: string): string {
  return title ? `${title} ${name}` : name;
}

// Paramètres par défaut
function power(base: number, exp: number = 2): number {
  return base ** exp;
}

// Rest parameters
function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0);
}

// Type d'une fonction
type Transformer<T, U> = (input: T) => U;
const toStr: Transformer<number, string> = (n) => String(n);

🔁 Surcharge de fonctions

// Signatures de surcharge
function format(val: number): string;
function format(val: string): string;
function format(val: Date): string;
// Implémentation (non visible à l'extérieur)
function format(val: number | string | Date): string {
  if (val instanceof Date) return val.toISOString();
  return String(val);
}

🧬 Génériques <T>

Les génériques permettent d'écrire du code réutilisable qui fonctionne avec plusieurs types tout en conservant la sécurité des types.

// Fonction générique
function identity<T>(value: T): T {
  return value;
}
identity("hello");  // T inféré → string
identity(42);      // T inféré → number
identity<boolean>(true); // T explicite

// Tableau générique — retourne le premier élément
function first<T>(arr: T[]): T | undefined {
  return arr[0];
}

// Plusieurs paramètres de type
function pair<A, B>(a: A, b: B): [A, B] {
  return [a, b];
}
pair("age", 30); // [string, number]

🔒 Contraintes avec extends

// T doit avoir une propriété length
function getLength<T extends { length: number }>(val: T): number {
  return val.length;
}
getLength("hello");      // OK — string a length
getLength([1, 2, 3]);   // OK — array a length
getLength(42);           // ❌ number n'a pas length

// keyof — accès à une propriété par clé
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const user = { name: "Alice", age: 30 };
getProperty(user, "name");  // OK → string
getProperty(user, "xyz");   // ❌ "xyz" n'existe pas

🛠️ Utility Types essentiels

// Exemples pratiques
interface User { id: number; name: string; password: string; }

type UserUpdate  = Partial<User>;              // tous optionnels
type PublicUser  = Omit<User, "password">;    // sans password
type UserPreview = Pick<User, "id" | "name">; // id + name