Vérifier si une valeur est un objet en JavaScript

Pour vérifier si une valeur JavaScript est un objet, utilisez typeof value === "object" && value !== null. Ce prédicat inclut les tableaux et les autres objets, mais exclut null et les fonctions. Si votre code doit aussi accepter les fonctions, ajoutez typeof value === "function" à la condition. Choisissez la règle adaptée aux besoins de votre programme : JavaScript traite les fonctions comme des objets appelables, tandis que typeof les distingue.

Utiliser instanceof pour vérifier si une valeur est un objet en JavaScript

instanceof est un opérateur qui vérifie si le prototype d’un constructeur figure dans la chaîne de prototypes d’une valeur. Pour un objet ordinaire créé dans le même environnement JavaScript, value instanceof Object est souvent vrai. Cet opérateur est donc utile pour vérifier si une valeur est une instance associée à un constructeur particulier, par exemple avec value instanceof Date.

Ce n’est pas un prédicat universel pour les objets. Un objet créé avec Object.create(null) n’a pas Object.prototype dans sa chaîne de prototypes : il échoue donc au test instanceof Object. Les objets créés dans un autre environnement, par exemple dans une autre fenêtre ou une autre iframe du navigateur, ont également des constructeurs et des prototypes différents. Un objet provenant de cet environnement peut donc échouer au test instanceof Object de l’environnement courant. Pour vérifier les objets de façon générale, y compris dans ces cas, utilisez un prédicat fondé sur typeof.

Utiliser typeof pour vérifier si une valeur est un objet en JavaScript

typeof est un opérateur, pas une fonction, et il n’est pas nécessaire de mettre sa valeur entre parenthèses. Pour les objets ordinaires, y compris les tableaux, typeof value renvoie "object". Deux résultats sont à retenir : typeof null renvoie aussi "object", tandis que typeof appliqué à une fonction renvoie "function". Ainsi, comparer uniquement le résultat à "object" inclut null et exclut les fonctions. Ajoutez un test explicite pour null si vous voulez reconnaître les objets sans inclure les valeurs nulles.

Définir un test réutilisable pour les objets

Ce prédicat renvoie true pour les objets qui ne sont pas nuls, et false pour les fonctions, les valeurs primitives et null. L’exemple montre le résultat pour un objet, une valeur nulle, un nombre et une fonction.

function isObject(value) {
  return value !== null && typeof value === "object";
}

const person = { name: "Ada" };
console.log(isObject(person));
console.log(isObject(null));
console.log(isObject(42));
console.log(isObject(() => {}));

Chaque appel affiche un résultat booléen, dans le même ordre que les valeurs fournies. Cette définition répond précisément à la question « s’agit-il d’un objet non nul ? ». Si les fonctions doivent aussi être prises en compte, utilisez value !== null && (typeof value === "object" || typeof value === "function"). Évitez de vérifier value.constructor.toString() à cette fin : une valeur peut ne pas avoir le constructeur attendu, et le nom ou le code source d’un constructeur ne constitue pas un test de type fiable dans tous les cas. Le modèle Object(value) === value effectue également des conversions qui peuvent brouiller le rôle exact du prédicat.

Utiliser Object.getPrototypeOf() pour examiner le prototype d’un objet

Object.getPrototypeOf(value) répond à une autre question : cette méthode renvoie le prototype d’un objet. Par exemple, Object.getPrototypeOf(Object.create(null)) renvoie null, tandis que Object.getPrototypeOf({}) renvoie Object.prototype. Cela peut servir à examiner l’héritage ou à comparer le prototype d’une valeur à un prototype connu, mais cette méthode ne remplace pas un prédicat d’objet. Passer null ou undefined à Object.getPrototypeOf() provoque une TypeError ; les autres valeurs primitives sont converties en objets avant que leur prototype soit renvoyé. Utilisez cette méthode uniquement lorsque vous devez examiner un prototype, et non comme test général pour déterminer si une valeur est un objet.