Ověřování tříd: „instanceof“

Operátor instanceof umožňuje ověřit, zda objekt patří do určité třídy. Bere v úvahu i dÄ›dičnost.

Toto ověření může být zapotřebí v mnoha případech. Například může být použito k vytvoření polymorfní funkce, takové, která zachází se svými argumenty různě v závislosti na jejich typu.

Operátor instanceof

Syntaxe je:

obj instanceof Třída

Vrací true, jestliže obj patří do třídy Třída nebo do třídy, která je z ní zdÄ›dÄ›na.

Například:

class Králík {}
let králík = new Králík();

// je to objekt třídy Králík?
alert( králík instanceof Králík ); // true

Funguje to i pro konstruktory:

// namísto třídy
function Králík() {}

alert( new Králík() instanceof Králík ); // true

…A pro zabudované třídy jako Array:

let pole = [1, 2, 3];
alert( pole instanceof Array ); // true
alert( pole instanceof Object ); // true

Prosíme vÅ¡imnÄ›te si, že pole patří i do třídy Object. Je to proto, že třída Array je prototypovÄ› zdÄ›dÄ›na z třídy Object.

NormálnÄ› instanceof pÅ™i ověřování prozkoumává prototypový Å™etÄ›zec. Můžeme si vÅ¡ak také nastavit vlastní logiku ve statické metodÄ› Symbol.hasInstance.

Algoritmus operátoru obj instanceof Třída funguje zhruba následovnÄ›:

1. Pokud existuje statická metoda Symbol.hasInstance, pak ji jen zavolá: Třída[Symbol.hasInstance](obj). Ta by mÄ›la vrátit buď true, nebo false, a jsme hotovi. Tímto způsobem si můžeme chování instanceof sami nastavit.

   Například:

   // nastavíme ověření instanceOf tak, aby předpokládalo,
   // že všechno, co má vlastnost můžeŽrát, je zvíře
   class Zvíře {
     static [Symbol.hasInstance](obj) {
       if (obj.můžeŽrát) return true;
     }
   }
   
   let obj = { můžeŽrát: true };
   
   alert(obj instanceof Zvíře); // true: zavolá se Zvíře[Symbol.hasInstance](obj)

2. VÄ›tÅ¡ina tříd nemá Symbol.hasInstance. V tom případÄ› je použita standardní logika: obj instanceOf Třída zjistí, zda se Třída.prototype rovná nÄ›kterému z prototypů v prototypovém Å™etÄ›zci objektu obj.

   Jinými slovy, porovnává jeden po druhém:

   obj.__proto__ === Třída.prototype?
   obj.__proto__.__proto__ === Třída.prototype?
   obj.__proto__.__proto__.__proto__ === Třída.prototype?
   ...
   // je-li kterákoli odpověď true, vrátí true
   // jinak, pokud jsme dosáhli konce řetězce, vrátí false

   V uvedeném příkladu králík.__proto__ === Králík.prototype, takže odpověď je vydána okamžitÄ›.

   V případě dědičnosti bude shoda nalezena ve druhém kroku:

   class Zvíře {}
   class Králík extends Zvíře {}
   
   let králík = new Králík();
   alert(králík instanceof Zvíře); // true
   
   // králík.__proto__ === Zvíře.prototype (není shoda)
   // králík.__proto__.__proto__ === Zvíře.prototype (shoda!)

Na tomto obrázku je vidÄ›t, co králík instanceof Zvíře porovnává se Zvíře.prototype:

Mimochodem, existuje také metoda objA.isPrototypeOf(objB), která vrátí true, jestliže se objA nachází nÄ›kde v prototypovém Å™etÄ›zci objektu objB. Test obj instanceof Třída tedy lze pÅ™epsat na Třída.prototype.isPrototypeOf(obj).

Veselé je, že samotný konstruktor Třída se na ověřování nepodílí! Záleží jen na prototypovém Å™etÄ›zci a na Třída.prototype.

To může vést k zajímavým důsledkům, když je vlastnost prototype zmÄ›nÄ›na po vytvoÅ™ení objektu.

Například zde:

function Králík() {}
let králík = new Králík();

// změníme prototyp
Králík.prototype = {};

// ...už to není králík!
alert( králík instanceof Králík ); // false

Bonus: Object.prototype.toString pro typ

Už víme, že plané objekty se pÅ™evádÄ›jí na Å™etÄ›zec jako [object Object]:

let obj = {};

alert(obj); // [object Object]
alert(obj.toString()); // totéž

Taková je jejich implementace metody toString. Existuje vÅ¡ak skrytá vlastnost, která činí toString ve skutečnosti mnohem silnÄ›jší. Můžeme ji používat jako rozšířený typeof a alternativu pro instanceof.

Zní to zvláštně? Určitě ano. Odhalme to.

Podle specifikace může být vestavÄ›ný toString extrahován z objektu a spuÅ¡tÄ›n v kontextu jakékoli jiné hodnoty. A na oné hodnotÄ› pak závisí jeho výsledek.

• Pro číslo to bude [object Number]
• Pro boolean to bude [object Boolean]
• Pro null: [object Null]
• Pro undefined: [object Undefined]
• Pro pole: [object Array]
• …atd. (nastavitelnÄ›).

Předveďme si to:

// pro přehlednost si zkopírujeme metodu toString do proměnné
let metodaToString = Object.prototype.toString;

// jakého typu je tohle?
let pole = [];

alert( metodaToString.call(pole) ); // [object Array]

Zde jsme použili metodu call, popsanou v kapitole Dekorátory a pÅ™esmÄ›rování, call/apply, ke spuÅ¡tÄ›ní funkce metodaToString v kontextu this=pole.

VnitÅ™nÄ› algoritmus metody toString prozkoumává this a vrací odpovídající výsledek. Další příklady:

let s = Object.prototype.toString;

alert( s.call(123) ); // [object Number]
alert( s.call(null) ); // [object Null]
alert( s.call(alert) ); // [object Function]

Symbol.toStringTag

Chování metody toString můžeme nastavit pomocí speciální objektové vlastnosti Symbol.toStringTag.

Například:

let uživatel = {
  [Symbol.toStringTag]: "Uživatel"
};

alert( {}.toString.call(uživatel) ); // [object Uživatel]

Tato vlastnost existuje u většiny objektů specifických pro určité prostředí. Uvedeme některé příklady specifické pro prohlížeč:

// toStringTag v objektu a třídě specifické pro určité prostředí:
alert( window[Symbol.toStringTag]); // Window
alert( XMLHttpRequest.prototype[Symbol.toStringTag] ); // XMLHttpRequest

alert( {}.toString.call(window) ); // [object Window]
alert( {}.toString.call(new XMLHttpRequest()) ); // [object XMLHttpRequest]

Jak vidíte, výsledkem je pÅ™esnÄ› Symbol.toStringTag (pokud existuje), zabalený do [object ...].

Nakonec tedy máme „typeof na steroidech“, který funguje nejen pro primitivní datové typy, ale i pro zabudované objekty a dokonce se dá nastavit.

Když tedy chceme u vestavÄ›ných objektů zjistit název typu jako Å™etÄ›zec a ne ho jen ověřit, můžeme místo instanceof používat {}.toString.call.

Shrnutí

Shrňme si metody pro ověření typu, které známe:

Jak vidíme, {}.toString je technicky „pokročilejší“ typeof.

A když pracujeme s třídní hierarchií a chceme si ověřit třídu, pÅ™ičemž chceme vzít v úvahu dÄ›dičnost, opravdu se zaleskne operátor instanceof.