undefined en JavaScript : 5 méthodes de vérification (et laquelle choisir)

« Uncaught ReferenceError » — votre premier ennemi ? Apprenez à vérifier correctement undefined en JavaScript

Quiconque a écrit ne serait-ce que quelques lignes en JavaScript a rencontré le mystérieux undefined. Ce n'est pas simplement un « espace vide » — c'est un type de données à part entière avec sa propre valeur. Mais comment le détecter correctement ? Si vous avez cherché « How can I check for undefined in JavaScript », vous n'êtes pas seul : cette question sur Stack Overflow a recueilli des centaines de milliers de vues. Le problème est qu'il existe plusieurs façons de vérifier en JS, et chacune cache des pièges.

Dans cet article, nous allons analyser 5 approches, de la plus simple à la plus complexe, comparer leurs performances et leur fiabilité, et déterminer quelle méthode utiliser en 2025. C'est parti !

Qu'est-ce que undefined en réalité ?

Avant de vérifier, mettons-nous d'accord sur les termes. undefined est une valeur primitive qui est attribuée à une variable si elle a été déclarée mais pas initialisée :

let a;\nconsole.log(a); // undefined\n

Important : undefined ≠ null ≠ not defined. null est un « rien » intentionnel, tandis que not defined (ReferenceError) se produit lorsque la variable n'est pas du tout déclarée. Ces nuances sont cruciales pour choisir la bonne vérification.

Méthode n°1 : L'opérateur typeof — l'étalon-or ?

La méthode la plus populaire et la plus sûre est d'utiliser typeof :

if (typeof x === 'undefined') {\n  console.log('x n\'est pas défini');\n}\n

Pourquoi cela fonctionne-t-il même pour les variables non déclarées ? typeof ne génère jamais de ReferenceError. Si la variable n'existe pas, il retourne simplement la chaîne "undefined".

Avantages :

\n
• Sûr pour les variables non déclarées
\n
• Code lisible et compréhensible
\n
• Fonctionne dans tous les navigateurs et environnements (Node.js, Deno)
\n

Inconvénients :

\n
• Un peu long pour une utilisation fréquente
\n
• Peut induire en erreur les débutants (comparaison de chaînes)
\n

Verdict : Le meilleur choix pour les vérifications globales et les cas où la variable peut ne pas être déclarée.

Méthode n°2 : Comparaison stricte avec undefined (===)

La deuxième méthode la plus populaire consiste à comparer directement la valeur :

if (x === undefined) {\n  console.log('x est égal à undefined');\n}\n

Il y a une nuance ici : la variable doit être déclarée. Si x n'existe pas, vous obtiendrez une ReferenceError. Par conséquent, ce code n'est sûr que pour :

\n
• Les propriétés d'objets (obj.prop === undefined)
\n
• Les paramètres de fonctions
\n
• Les variables déclarées avec let, const ou var
\n

Piège : undefined global

Dans les anciens navigateurs (IE 8 et inférieur), undefined pouvait être réécrit :

undefined = 'je suis maintenant une chaîne'; // Cauchemar !\n

Ce n'est plus possible aujourd'hui (en mode strict), mais si vous supportez du code legacy, utilisez plutôt typeof.

Verdict : Excellente méthode pour les variables locales et les propriétés d'objets. Rapide et concise.

Méthode n°3 : L'opérateur void

Une méthode peu connue mais élégante — void 0 :

if (x === void 0) {\n  console.log('x undefined');\n}\n

L'opérateur void évalue une expression et retourne undefined. void 0 est le moyen le plus court d'obtenir un undefined pur, indépendant de la variable globale.

Quand est-ce utile ?

\n
• Dans le code minifié (économie d'octets)
\n
• Dans les bibliothèques où la protection contre la redéfinition de undefined est importante
\n
• En programmation fonctionnelle (par exemple, dans les chaînes de promesses)
\n

Inconvénient : Cela semble étrange