Ce verifică operatorul instanceof în JavaScript?

Operatorul instanceof în JavaScript verifică dacă un obiect este o instanță a unei anumite clase sau constructor.

Principiul de funcționare:

1. Operatorul instanceof verifică prezența prototype-ului constructorului în lanțul de prototipuri al obiectului.
2. Dacă prototype-ul constructorului se află în lanț, rezultatul este true.
3. În caz contrar, rezultatul este false.

Exemple:

// Creăm o clasă
class Animal {
  // Constructor
  constructor(name) {
    this.name = name;
  }
}

// Creăm o instanță a clasei
let dog = new Animal("Buddy");

// Verificăm dacă dog este o instanță a Animal
console.log(dog instanceof Animal); // true

// Verificăm dacă dog este o instanță a Object (este, prin lanțul de prototipuri)
console.log(dog instanceof Object); // true

// Verificăm dacă dog este o instanță a Array (nu este)
console.log(dog instanceof Array); // false

// Verificare cu tipuri încorporate
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 (pentru primitive, instanceof se comportă specific)
// Pentru primitive create cu new
let numObj = new Number(123);
console.log(numObj instanceof Number); // true

Caracteristici:

• instanceof funcționează prin lanțul de prototipuri, deci rezultatul poate fi true pentru constructorii părinte.
• Pentru tipurile primitive (string, number, boolean, null, undefined, symbol, bigint), instanceof returnează de obicei false dacă nu au fost create prin obiectul de tip corespunzător (new String(), new Number(), etc.).
• Poate fi imprecis când se lucrează cu diferite contexte de execuție JavaScript (de exemplu, ferestre sau iframe-uri diferite), deoarece fiecare context are propriile sale constructori.

Abordări similare pentru verificarea tipului:

• typeof: returnează un șir care indică tipul de bază al datelor (string, number, boolean, object, function, undefined, symbol, bigint). Nu este potrivit pentru verificarea apartenenței la o anumită clasă.
• Object.prototype.toString.call(): returnează un șir mai precis cu tipul obiectului ("[object Array]", "[object Date]", etc.).

În general, instanceof este util pentru verificarea dacă un obiect aparține unei anumite clase sau părintelui acesteia în ierarhia de moștenire.