Que vérifie l'opérateur instanceof en JavaScript…

L'opérateur instanceof en JavaScript vérifie si un objet est une instance d'une classe ou d'un constructeur spécifique.

Principe de fonctionnement:

L'opérateur instanceof vérifie la présence de prototype du constructeur dans la chaîne de prototypes de l'objet.
Si prototype du constructeur est présent dans la chaîne, le résultat est true.
Sinon, le résultat est false.

Exemples:

// Créer une classe
class Animal {
  // Constructeur
  constructor(name) {
    this.name = name;
  }
}

// Créer une instance de la classe
let dog = new Animal("Buddy");

// Vérifier si dog est une instance de Animal
console.log(dog instanceof Animal); // true

// Vérifier si dog est une instance de Object (il l'est, via la chaîne de prototypes)
console.log(dog instanceof Object); // true

// Vérifier si dog est une instance de Array (ce n'est pas le cas)
console.log(dog instanceof Array); // false

// Vérification avec types intégrés
let arr = [1, 2, 3];
console.log(arr instanceof Array); // true
console.log(arr instanceof Object); // true

let num = 123;
console.log(num instanceof Number); // false (pour les primitives, instanceof se comporte de manière spécifique)
// Pour les primitives créées avec new
let numObj = new Number(123);
console.log(numObj instanceof Number); // true

Caractéristiques:

instanceof fonctionne à travers la chaîne de prototypes, donc le résultat peut être true pour les constructeurs parentaux.
Pour les types primitifs (string, number, boolean, null, undefined, symbol, bigint), instanceof retourne généralement false s'ils n'ont pas été créés via l'objet wrapper correspondant (new String(), new Number(), etc.).
Peut être inexact dans différents contextes d'exécution JavaScript (par exemple, différentes fenêtres ou iframe), car chaque contexte a ses propres constructeurs.

Approches similaires pour vérifier le type:

typeof: retourne une chaîne indiquant le type de base (string, number, boolean, object, function, undefined, symbol, bigint). Ne convient pas pour vérifier l'appartenance à une classe spécifique.
Object.prototype.toString.call(): retourne une chaîne plus précise du type de l'objet ("[object Array]", "[object Date]", etc.).

En résumé, instanceof est utile pour vérifier si un objet appartient à une classe ou à son ancêtre dans la hiérarchie d'héritage.

Que vérifie l'opérateur instanceof en JavaScript?