TypeScript Academy · Leçon

void, never et signatures de fonctions

Comprenez void pour les fonctions sans retour et never pour le code inaccessible

void, never et signatures de fonctions est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. 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 4 leçons au total.

Bienvenue

Deux types de retour particuliers — void et never — représentent les fonctions qui ne produisent aucune valeur utile et celles qui ne se terminent jamais normalement.

void : aucune valeur utile

void s’utilise lorsqu’une fonction produit un effet de bord, mais ne renvoie aucune valeur. Il autorise le renvoi de undefined, tout en indiquant que la valeur de retour ne doit pas être utilisée.

function logError(msg: string): void {
  console.error(msg);
  // implicit return undefined
}

Différence entre void et undefined

void et undefined sont similaires, mais différents. Une fonction typée void peut renvoyer undefined. Cependant, void indique que l’appelant doit ignorer la valeur de retour.

const fn: () => void = () => 42; // Allowed! Caller ignores return
const fn2: () => undefined = () => 42; // Error

void dans les fonctions de rappel

Lors du typage d’un paramètre de fonction de rappel, void indique que l’appelant n’utilise pas la valeur de retour. Cela permet aux fonctions de rappel de renvoyer n’importe quel type.

function run(cb: () => void): void { cb(); }
run(() => 'hello'); // OK — return value ignored

never : le type inaccessible

never représente une valeur qui ne se produit jamais. Une fonction qui renvoie never lève une erreur ou boucle indéfiniment.

function fail(msg: string): never {
  throw new Error(msg);
}
function loop(): never {
  while (true) {}
}

never dans les vérifications d’exhaustivité

never s’utilise dans les instructions switch pour garantir que tous les cas d’une union sont traités. Une affectation à never provoque une erreur si un cas est oublié.

type Shape = 'circle' | 'square';
function area(s: Shape): number {
  switch (s) {
    case 'circle': return 3.14;
    case 'square': return 1;
    default:
      const _: never = s; // Error if a new shape is added
      return 0;
  }
}

never est un sous-type de tout

never peut être affecté à n’importe quel type (puisque cela ne se produit jamais, il satisfait par vacuité tous les types). Aucun autre type ne peut être affecté à never.

Signatures de types de fonctions

Un type de fonction s’écrit `(param: Type) => ReturnType`. Cela décrit les fonctions comme des valeurs de première classe.

type Handler = (event: MouseEvent) => void;
type Transform = (input: string) => string;

Signatures d’appel dans les interfaces

Les interfaces peuvent définir des types appelables à l’aide de la syntaxe d’une signature d’appel.

interface Formatter {
  (value: string): string;
  locale: string;
}

Signatures de construction

Les interfaces peuvent également définir des types instanciables en utilisant le mot-clé new dans une signature de construction.

interface Constructor {
  new (name: string): Animal;
}

Combiner void et never dans la gestion des erreurs

Les fonctions qui lèvent toujours une erreur utilisent never. Les fonctions qui ignorent les erreurs et ne renvoient rien utilisent void. Cette distinction est importante pour l’analyse du flux de contrôle.

function orThrow(val: string | null): string {
  if (val === null) fail('null!'); // never
  return val; // TypeScript knows this is reachable
}

Vérification rapide

Quel type de retour indique qu’une fonction lèvera toujours une erreur et ne renverra jamais de valeur normalement ?

Récapitulatif

Utilisez void pour les fonctions produisant des effets de bord sans valeur de retour utile. Utilisez never pour les fonctions qui lèvent une erreur ou bouclent indéfiniment. never permet la vérification d’exhaustivité et est un sous-type de tous les types.

Questions Fréquemment Posées

La leçon « void, never et signatures de fonctions » est-elle gratuite ?

Oui — le texte complet de « void, never et signatures de fonctions » 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 4 leçons au total.

Qu'est-ce que j'apprendrai dans « void, never et signatures de fonctions » ?

Comprenez void pour les fonctions sans retour et never pour le code inaccessible 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 4 sur 4.

Combien de temps prend la leçon « void, never et signatures de fonctions » ?

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

Annotations de types des paramètres et des valeurs de retour
Paramètres facultatifs et par défaut
Paramètres rest et opérateur spread avec des types
void, never et signatures de fonctions

← Retour à TypeScript Academy