undefined ou null en JavaScript : comment vérifier une variable en 2025

« Variable non définie » : pourquoi cette question tourmente-t-elle tout le monde ?

Si vous avez déjà écrit du JavaScript, vous avez forcément été confronté à cette situation : vous lancez le code, et dans la console apparaît un message rouge Uncaught TypeError: Cannot read properties of undefined. Ou pire encore — null is not an object. Ça vous parle ? C'est l'une des erreurs les plus fréquentes qui poursuit les développeurs de tous niveaux.

La question « How can I determine if a variable is 'undefined' or 'null'? » sur Stack Overflow a rassemblé des milliers de vues et des centaines de réponses. Et ce n'est pas un hasard : en JavaScript, ces deux valeurs se ressemblent mais se comportent différemment. En 2025, alors que le code devient plus complexe et les projets plus vastes, savoir vérifier correctement undefined et null passe de « bon à savoir » à « indispensable à maîtriser ».

Dans cet article, nous allons passer en revue toutes les méthodes de vérification, des plus simples aux plus avancées, et montrer lesquelles utiliser dans le développement moderne. C'est parti !

undefined vs null : quelle est la différence ?

Avant de vérifier, comprenons de quoi il s'agit. En JavaScript, undefined et null sont deux valeurs primitives différentes, chacune avec son propre type.

undefined

undefined est la valeur attribuée automatiquement à une variable si vous l'avez déclarée mais sans lui donner de valeur. Une fonction renvoie également undefined si elle ne contient pas de return explicite.

let myVar;\nconsole.log(myVar); // undefined\n\nfunction doNothing() {}\nconsole.log(doNothing()); // undefined\n\nconsole.log(someNonExistentVariable); // ReferenceError, mais si on accède à une propriété d'un objet :\nconst obj = {};\nconsole.log(obj.prop); // undefined\n

null

null est une valeur que le développeur attribue intentionnellement. Elle signifie « vide », « rien », « valeur absente ». null est un objet du point de vue de typeof (oui, c'est un bug historique, mais il est devenu une fonctionnalité).

let myVar = null;\nconsole.log(myVar); // null\nconsole.log(typeof myVar); // "object" — oui, c'est ainsi !\n

La principale différence : undefined signifie « pas encore assigné », tandis que null signifie « intentionnellement vide ». Mais avec une comparaison non stricte, ils sont égaux :

console.log(null == undefined); // true\nconsole.log(null === undefined); // false\n

C'est à cause de cette égalité non stricte que la confusion survient. C'est pourquoi les meilleures pratiques de 2025 recommandent d'utiliser la comparaison stricte (===).

Top 5 des méthodes pour vérifier undefined et null

Passons en revue toutes les méthodes populaires, des plus simples aux plus modernes. Nous évaluerons chacune selon trois critères : lisibilité, fiabilité et performance.

1. Comparaison stricte (===) — l'étalon-or

La méthode la plus directe et la plus claire consiste à comparer directement la variable avec undefined ou null via ===.

let value = null;\n\n// Vérification de null\nif (value === null) {\n    console.log('C\'est null');\n}\n\n// Vérification de undefined\nif (value === undefined) {\n    console.log('C\'est undefined');\n}\n\n// Vérification de null OU undefined (séparément)\nif (value === null || value === undefined) {\n    console.log('Valeur absente');\n}\n

Pourquoi est-ce la meilleure pratique ?

\n
• Maximum de lisibilité — tout développeur comprendra ce que vous vérifiez.
\n
• Pas de conversions de type inattendues.
\n
• Fonctionne dans toutes les versions de JavaScript, y compris les plus anciennes.
\n

Inconvénient : Si vous devez vérifier les deux valeurs à la fois, vous devez écrire deux conditions. Mais cela se résout avec l'opérateur ||, comme dans l'exemple ci-dessus.

2. Opérateur de coalescence nulle (??) — la nouveauté qui a fait son chemin

Depuis ES2020, JavaScript dispose de l'opérateur ?? (nu