L'opérateurinstanceof permet de tester si un objet possède, dans sa chaîne de prototype, la propriétéprototype d'un certain constructeur.

Exemple interactif

function Car(make, model, year) {  this.make = make;  this.model = model;  this.year = year;}const auto = new Car("Honda", "Accord", 1998);console.log(auto instanceof Car);// Expected output: trueconsole.log(auto instanceof Object);// Expected output: true

Syntaxe

objet instanceof constructeur;

Paramètres

objet

L'objet qu'on souhaite analyser.

constructeur

La fonction dont on souhaite vérifier la présence dans la chaîne de prototypes.

Description

L'opérateurinstanceof teste la présence deconstructeur.prototype dans la chaîne de prototypes d'objet.

function C() {} // Définition du constructeurfunction D() {} // Définition d'un autre constructeurvar o = new C();// true, car : Object.getPrototypeOf(o) === C.prototypeo instanceof C;// false, car D.prototype n'existe pas dans la chaîne de prototype de oo instanceof D;o instanceof Object; // true, car:C.prototype instanceof Object; // trueC.prototype = {};var o2 = new C();o2 instanceof C; // true// false, car C.prototype n'existe plus dans la chaîne de prototype de oo instanceof C;D.prototype = new C(); // Utilisation de l'héritagevar o3 = new D();o3 instanceof D; // trueo3 instanceof C; // true car C.prototype fait partie de la chaîne de o3

À noter que la valeur retournée parinstanceof peut être différente suite à un changement de la propriétéprototype du constructeur, notamment via la méthodeObject.setPrototypeOf(). On peut aussi utiliser la pseudo-propriété__proto__ qui n'était pas standard avant ECMAScript 2015.

instanceof dans d'autres contextes (frames ou fenêtres)

Différents niveaux d'intégrations ont différents environnements. Cela signifie que les valeurs retournées sont différentes (objet globaux différents, constructeurs différents, etc.). Cela peut engendrer des résultats inattendus. Par exemple,[] instanceof window.frames[0].Array renverrafalse, carArray !== window.frames[0].Array et que les tableaux héritent de leur constructeur.

Cela peut être contre-intuitif au début, mais lorsqu'il est nécessaire de travailler avec plusieurs frames ou fenêtres, et que des objets sont transférés via des fonctions, cela sera un obstacle valide et important. Par contre, il est tout à fait possible d'utiliserArray.isArray(myObj) pour vérifier de manière sécurisée qu'un tableau est effectivement un tableau.

Ainsi, pour vérifier qu'unnœud est bien un objet de typeSVGElement dans un autre contexte, on pourra utilisermonNœud instanceof monNœud.documentMaitre.vue.SVGElement.

Exemples

Démonstration queString etDate sont de typeObject et cas aux limites des littéraux

Le code suivant utiliseinstanceof pour démontrer que les objetsString etDate sont aussi de typeObject (ils dérivent d'Object).

Cependant, les objets créés à partir de littéraux objets sont une exception : en effet, bien que leur prototype ne soit pas défini,instanceof Object renvoietrue.

var chaîneSimple = "Une chaîne simple";var maChaîne  = new String();var newChaîne = new String("Chaîne créée avec un constructeur");var maDate    = new Date();var monObjet  = {};var monNonObjet = Object.create(null);chaîneSimple instanceof String; //false car le prototype vaut undefinedmaChaîne instanceof String; // truenewChaîne instanceof String; // truemaChaîne instanceof Object; // truemonObjet instanceof Object;  // true, bien que le protoype soit undefined({}) instanceof Object;      // true, comme pour le cas précédentmonNonObjet instance Object; // falsemaChaîne instanceof Date;    // falsemaDate instanceof Date;      // truemaDate instanceof Object;    // truemaDate instanceof String;    // false

Démonstration quemavoiture est de typeVoiture et de typeObject

Le code suivant créé un objet de typeVoiture et une instance de cet objet,mavoiture. L'opérateurinstanceof montre que l'objetmavoiture est de typeVoiture et de typeObject.

function Voiture(fabricant, modele, annee) {  this.fabricant = fabricant;  this.modele = modele;  this.annee = annee;}var mavoiture = new Voiture("Citroën", "C3", 2006);var a = mavoiture instanceof Voiture; // retourne truevar b = mavoiture instanceof Object; // retourne true

Attention à la précédence des opérateurs

Pour tester qu'un objet n'est pas une instance d'un constructeur donné, on pourra faire le test!(monObj instanceof Constructor). Toutefois, attention à ne pas écrire!monObj instanceof Constructor car!monObj serait traité en priorité et on testerait doncfalse instanceof Constructor qui sera toujours faux.

Spécifications

Compatibilité des navigateurs

Voir aussi

• typeof
• Symbol.hasInstance