Surcharges de fonctions et signatures d’appel
Déclarez des signatures de surcharge pour différentes formes d’appel et utilisez des signatures d’appel dans les types d’objets pour créer des API flexibles.
Surcharges de fonctions et signatures d’appel est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 3 leçons au total.
Introduction
Objectif : modéliser des fonctions qui acceptent différentes entrées et renvoient différentes sorties à l'aide de surcharges, et décrire des signatures d'appel dans des types d'objets pour les API de type fonction de rappel.
Modèle de surcharge
Les surcharges sont déclarées sous la forme de plusieurs signatures suivies d'une seule implémentation, qui affine les entrées et renvoie le type correct.
// 1) Overload signatures (no body)
function parse(input: string): number;
function parse(input: number): string;
// 2) Single implementation compatible with all overloads
function parse(input: string | number): string | number {
if (typeof input === "string") {
return input.length; // string -> number
} else {
return String(input); // number -> string
}
}
console.log(parse("TS")); // 2 (number)
console.log(parse(123)); // "123" (string)Signatures d'appel
Une signature d'appel permet à un type d'objet d'être appelable avec des surcharges (utile pour les bibliothèques qui exposent des fonctions appelables avec des propriétés).
type Stringify = {
(v: number): string;
(v: boolean): string;
};
const toStr: Stringify = (v: number | boolean) => {
return typeof v === "number" ? v.toFixed(1) : (v ? "true" : "false");
};
console.log(toStr(3));
console.log(toStr(false));Raffinement dans l'implémentation
L'implémentation doit gérer toutes les formes de surcharge. Utilisez des vérifications in ou des unions discriminées pour effectuer un branchement sûr.
function area(value: { r: number } | { w: number; h: number }): number {
if ("r" in value) {
return Math.PI * value.r ** 2; // circle
}
return value.w * value.h; // rect
}
console.log(area({ r: 2 }));
console.log(area({ w: 3, h: 4 }));Surcharges ou unions
Surcharges ou unions :
- Les surcharges fournissent des types de retour précis pour chaque appel.
- Les unions conservent une signature unique, plus simple mais moins spécifique.
- Choisissez les surcharges lorsque les appelants bénéficient de types de retour exacts.
Conseils de DX
Conseils :
- Gardez le nombre de surcharges réduit et leur définition claire.
- Documentez les différences entre les paramètres et les valeurs de retour.
- Privilégiez la précision du type de retour lorsqu'elle améliore l'expérience utilisateur.
Vérification des surcharges
Vérification rapide : Quel modèle déclare correctement des surcharges de fonction ?
Récapitulatif
Récapitulatif : Utilisez les surcharges pour obtenir des types précis à chaque appel et les signatures d'appel pour modéliser des objets appelables. Effectuez le raffinement dans l'unique implémentation afin de couvrir tous les cas.
Questions Fréquemment Posées
La leçon « Surcharges de fonctions et signatures d’appel » est-elle gratuite ?
Oui — le texte complet de « Surcharges de fonctions et signatures d’appel » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Surcharges de fonctions et signatures d’appel » ?
Déclarez des signatures de surcharge pour différentes formes d’appel et utilisez des signatures d’appel dans les types d’objets pour créer des API flexibles. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer TypeScript Academy ?
Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.
Combien de temps prend la leçon « Surcharges de fonctions et signatures d’appel » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?
Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Surcharges de fonctions et signatures d’appel
- Typage du paramètre this ; void, never
- Fonctions d’assertion et gardes de types définis par l’utilisateur