Deux façons de dire « rien »
La plupart des langages ont une seule valeur pour représenter l'absence. JavaScript en a deux : null et undefined. Leur comportement se ressemble assez pour embrouiller les débutants, et diffère juste assez pour piéger les développeurs aguerris. Comprendre la différence entre null et undefined en JavaScript mérite bien dix minutes de votre temps.
En résumé :
undefined, c'est ce que JavaScript vous renvoie quand quelque chose manque.null, c'est ce que vous écrivez vous-même pour signaler « volontairement vide ».
Vous voyez le schéma : chaque undefined ci-dessus apparaît parce que JavaScript n'a pas trouvé de valeur. Le null, lui, est là parce que quelqu'un l'a écrit explicitement.
D'où vient undefined ?
undefined surgit dans une poignée de situations bien précises, toutes des variantes du même thème : « aucune valeur disponible ».
Dans tous les cas, JavaScript est allé chercher une valeur et n'a rien trouvé. undefined, c'est la façon qu'a le moteur de dire : « J'ai regardé, il n'y avait rien. »
Techniquement, tu peux affecter undefined toi-même (let x = undefined;), mais évite. Laisse-le jouer son rôle de signal : « JavaScript n'a rien trouvé. » Quand c'est toi qui prends la décision, utilise plutôt null.
D'où vient null en JavaScript
null n'apparaît jamais tout seul : il faut que quelqu'un l'ait écrit. C'est tout l'intérêt — c'est un marqueur intentionnel.
Les APIs du DOM utilisent beaucoup null : document.getElementById("missing") renvoie null, pas undefined, parce que le navigateur te dit explicitement « j'ai cherché, et la réponse est : aucun élément ». Pareil pour JSON.parse("null"), qui te donne null — le format JSON ne connaît tout simplement pas undefined.
Le modèle mental à retenir : undefined est l'absence par défaut, null est une absence choisie.
Le piège de typeof
Voilà le cas célèbre :
typeof null qui renvoie "object", c'est un bug datant de 1995 qu'on n'a jamais pu corriger sans casser des sites existants — du coup, il est resté là pour toujours. null n'est pas un objet : c'est une primitive, au même titre qu'undefined, les nombres, les chaînes ou les booléens. C'est simplement typeof qui ment à son sujet.
Conséquence concrète : typeof ne sert à rien pour détecter null. Il faut passer par une comparaison directe :
Ou, plus souvent, vérifier les deux d'un coup — voyons ça dans la section suivante.
Tester null ou undefined en JavaScript : l'astuce == null
La plupart du temps, on se fiche de savoir laquelle des deux valeurs absentes on a sous la main — on veut juste s'assurer qu'il y a bien quelque chose avant de s'en servir. L'idiome consacré, c'est l'égalité faible avec null :
value == null renvoie true uniquement pour null et undefined, et false pour tout le reste — y compris 0, "" et false, ce qui correspond généralement à ce qu'on veut. C'est l'unique cas où == est préférable à ===. Les linters le savent et tolèrent cette écriture.
Si vous préférez être explicite, value === null || value === undefined veut dire la même chose et se lit très clairement.
Les opérateurs nullish : ?? et ?.
Deux opérateurs ont été ajoutés au langage justement pour faciliter le travail avec null et undefined. Tous les deux traitent ces deux valeurs de la même manière et ignorent le reste.
Le coalescing nullish (??) fournit une valeur de repli uniquement si l'opérande de gauche vaut null ou undefined :
À comparer avec ||, qui remplacerait 0 par 3 puisque 0 est falsy. ?? est plus strict : il ne se déclenche que pour les deux valeurs nullish.
Le chaînage optionnel (?.) interrompt l'évaluation d'une chaîne et renvoie undefined dès qu'il tombe sur null ou undefined :
Les deux opérateurs existent précisément parce que la question « cette valeur est-elle nullish ? » revient sans arrêt. On les aborde plus en détail plus loin dans le cursus.
Les paramètres par défaut ne se déclenchent que pour undefined
Voici une règle subtile mais cruciale : les valeurs par défaut des paramètres ne s'activent que si l'argument vaut undefined, jamais null.
Passer null signifie « j'ai choisi explicitement de ne pas mettre de valeur », et c'est respecté tel quel. Si tu veux que null déclenche aussi la valeur par défaut, utilise ?? à l'intérieur de la fonction :
Cette distinction piège pas mal de monde. Les valeurs par défaut gèrent les arguments manquants ; ?? gère les arguments nullish.
JSON et l'absence d'undefined
JSON connaît null, mais pas undefined. Résultat : des surprises silencieuses au moment de sérialiser :
Le champ age a complètement disparu : JSON.stringify supprime purement et simplement les propriétés dont la valeur est undefined. À l'inverse, null est conservé, car JSON le prend en charge nativement. Faire un aller-retour d'un objet via JSON est d'ailleurs une façon courante de voir des propriétés undefined s'évaporer sans crier gare.
Dans les tableaux, undefined est converti en null :
Si tu construis le payload d'une API, préfère null à undefined pour les champs « sans valeur ». C'est le seul des deux qui survit au voyage.
Quand utiliser null et quand utiliser undefined
Voici une convention qui tient la route dans ton propre code :
- Laisse
undefinedsignifier « non fourni » — arguments manquants, variables non initialisées, propriétés absentes. Ne l'assigne jamais à la main. - Utilise
nullquand tu veux dire explicitement « c'est vide, et c'est voulu » : un utilisateur déconnecté, une option non sélectionnée, un champ de formulaire vidé. - Aux frontières de ton API, accepte les deux (avec
== nullou??), mais reste cohérent sur celui que tu produis.
Certains guides de style (dont celui de TypeScript) font carrément l'impasse sur null et n'utilisent que undefined. Ça se défend — une seule valeur, c'est plus simple que deux. Choisis une règle par projet et tiens-t'y partout.
La suite : la coercition de type
null et undefined se comportent chacun à leur manière quand JavaScript les convertit en nombres, en chaînes ou en booléens — Number(null) vaut 0, mais Number(undefined) donne NaN, et ce genre d'asymétrie provoque de vrais bugs. On attaque la coercition de type juste après, et une fois que tu auras les règles complètes en tête, beaucoup de bizarreries de JavaScript cesseront d'en être.
Questions fréquentes
Quelle est la différence entre null et undefined en JavaScript ?
undefined signifie qu'aucune valeur n'a encore été affectée : c'est ce que JavaScript renvoie pour une variable non initialisée, un argument manquant ou une propriété d'objet inexistante. null, lui, est une absence de valeur volontaire, que vous assignez vous-même. JavaScript ne produit jamais null tout seul — il faut l'écrire explicitement.
Comment tester null et undefined en une seule fois ?
Utilisez value == null. L'égalité faible considère que null et undefined sont égaux entre eux, mais à rien d'autre : x == null est donc vrai uniquement pour ces deux valeurs. C'est le seul cas où l'on préfère == à === sans se faire taper sur les doigts.
Pourquoi typeof null renvoie 'object' ?
C'est un bug qui traîne depuis la toute première version de JavaScript, et qu'on ne peut plus corriger sans casser la moitié du web. typeof null renvoie 'object' alors que null est bel et bien une primitive. Pour tester précisément null, comparez directement : value === null.
Faut-il utiliser null ou undefined dans son propre code ?
Laissez undefined représenter « rien n'a été fourni » et réservez null pour signaler « c'est volontairement vide ». Beaucoup de codebases (et le style guide TypeScript) évitent carrément null et se contentent d'undefined. L'essentiel : choisir une convention par projet et s'y tenir.
