TypeScript Academy · Leçon

Le type void dans les fonctions

Comprendre la différence entre void et undefined dans les positions de retour des fonctions.

Le type void dans les fonctions est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Le type de retour vide

void décrit une fonction qui ne renvoie aucune valeur utile. La fonction s'achève tout de même ; elle ne produit simplement rien que vous devriez utiliser. C'est le type des fonctions appelées pour leurs effets de bord.

function log(message: string): void {
  console.log(message);
}
log('Hello void');

Type vide inféré

Si une fonction ne contient aucune instruction return (ou uniquement une instruction return; sans valeur), TypeScript déduit automatiquement le type void. Vous devez rarement l'écrire explicitement, même si cela documente l'intention.

function greet(name: string) {
  console.log('Hi ' + name);
  // no return -> inferred void
}
greet('Ada');

Type vide et valeur indéfinie

Ces notions sont liées, mais différentes. Une fonction de type void peut réellement renvoyer ou non undefined, et vous ne devez pas vous fier à sa valeur de retour. Une fonction dont le type de retour est undefined doit renvoyer explicitement cette valeur.

function a(): void { /* returns nothing useful */ }
function b(): undefined { return undefined; }
console.log(a(), b());

Vous ne devez pas utiliser un résultat de type vide

À l'exécution, la valeur d'un appel de type void est undefined, mais le système de types vous déconseille de l'utiliser. Considérez void comme « ignorer cette valeur de retour ».

function save(): void {
  console.log('saved');
}
const result = save(); // result has type void
console.log(result); // undefined at runtime

Le type vide dans les types de fonctions de rappel

Voici une règle subtile et puissante : une fonction de rappel dont le type de retour est void peut être satisfaite par une fonction qui renvoie n'importe quelle valeur. La valeur de retour supplémentaire est simplement ignorée.

type Handler = () => void;

const h: Handler = () => 42; // returns number, still fine
h();
console.log('Returned value is ignored by callers');

Pourquoi cette règle existe

Cette souplesse vous permet de transmettre des fonctions comme arr.push (qui renvoie un nombre) en tant que fonctions de rappel de type void. L'appelant s'est engagé à ne pas utiliser la valeur de retour ; tout retour est donc sans danger.

const items: number[] = [];
const nums = [1, 2, 3];
nums.forEach((n) => items.push(n)); // push returns number, ok
console.log(items);

Le type vide contextuel dans les méthodes de tableau

forEach attend une fonction de rappel qui renvoie void. C'est pourquoi vous pouvez écrire une fonction fléchée sur une seule ligne qui renvoie incidemment une valeur sans provoquer d'erreur : le type void contextuel l'absorbe.

const result: string[] = [];
['a', 'b'].forEach((x) => result.push(x.toUpperCase()));
console.log(result);

Une confusion fréquente

La règle concernant les fonctions de rappel de type void s'applique au type de la fonction de rappel, et non aux fonctions dont le propre type de retour annoté est void. Une fonction déclarée littéralement (): void ne peut toujours pas contenir un return value; avec une valeur différente de undefined.

function f(): void {
  return; // ok
  // return 5; // Error: 5 not assignable to void
}
f();
console.log('declared void cannot return a value');

Les paramètres de type vide sont inhabituels

Bien que ce soit rare, void peut apparaître comme type de paramètre dans des génériques avancés. Dans le code courant, vous le verrez presque toujours comme type de retour, signalant « aucun résultat significatif ».

type Listener = (event: string) => void;

const onClick: Listener = (e) => console.log('Event:', e);
onClick('click');

Le type vide avec les promesses

Les fonctions asynchrones renvoient souvent Promise<void> lorsqu'elles effectuent une opération mais se résolvent sans valeur. Ce modèle reprend le fonctionnement synchrone de void pour le code asynchrone.

async function sync(): Promise<void> {
  console.log('syncing...');
  // resolves with no value
}
sync().then(() => console.log('done'));

Choisir délibérément le type vide

Annotez le type void lorsque vous voulez indiquer qu'une fonction existe pour ses effets de bord et que les appelants ne doivent pas dépendre d'une valeur de retour. Cela clarifie l'intention et vous permet de tirer parti de la règle flexible concernant les fonctions de rappel.

function notify(msg: string): void {
  console.log('NOTIFY:', msg);
}
const handlers: Array<(m: string) => void> = [notify];
handlers.forEach((fn) => fn('ping'));

Vérification rapide

Vérifiez votre compréhension du type void.

Récapitulatif : type vide

Vous avez appris que void :

Indique les fonctions qui renvoient aucune valeur utile.
Se distingue de undefined : les résultats de type void ne doivent pas être utilisés.
En tant que type de fonction de rappel, accepte les fonctions qui renvoient n'importe quelle valeur, laquelle est ignorée par les appelants.
Permet d'utiliser proprement des méthodes comme push dans forEach.

Ensuite, nous réunirons toutes ces notions pour gérer unknown en toute sécurité.

const tasks: Array<() => void> = [
  () => console.log('task 1'),
  () => console.log('task 2')
];
tasks.forEach((t) => t());

Questions Fréquemment Posées

La leçon « Le type void dans les fonctions » est-elle gratuite ?

Oui — le texte complet de « Le type void dans les 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 « Le type void dans les fonctions » ?

Comprendre la différence entre void et undefined dans les positions de retour des fonctions. 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 3 sur 4.

Combien de temps prend la leçon « Le type void dans les 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

Comprendre unknown et any
Le type never et les états impossibles
Le type void dans les fonctions
Manipuler unknown avec la sécurité du typage

← Retour à TypeScript Academy