Prototypové metody, objekty bez __proto__

V první kapitole této sekce jsme se zmínili, že existují moderní metody, jak nastavit prototyp.

Nastavování nebo čtení prototypu pomocí obj.__proto__ je považováno za zastaralé a je mírnÄ› zavrhováno (je pÅ™esunuto do části standardu JavaScriptu nazvané „Příloha B“, která je určena výhradnÄ› pro prohlížeče).

Moderní metody pro načtení a nastavení prototypu jsou:

• Object.getPrototypeOf(obj) – vrátí [[Prototype]] objektu obj.
• Object.setPrototypeOf(obj, proto) – nastaví [[Prototype]] objektu obj na proto.

Jediné využití __proto__, nad kterým se lze nezamračit, je použít ho jako vlastnost pÅ™i vytvoÅ™ení nového objektu: { __proto__: ... }.

Ačkoli i k tomu existuje speciální metoda:

• Object.create(proto[, deskriptory]) – vytvoří prázdný objekt, jehož [[Prototype]] bude proto, s možností uvést jeho deskriptory vlastností.

Například:

let zvíře = {
  žere: true
};

// vytvoří nový objekt, jehož prototypem je zvíře
let králík = Object.create(zvíře); // totéž jako {__proto__: zvíře}

alert(králík.žere); // true

alert(Object.getPrototypeOf(králík) === zvíře); // true

Object.setPrototypeOf(králík, {}); // změní prototyp objektu králík na {}

Metoda Object.create je trochu silnÄ›jší, jelikož má nepovinný druhý argument: deskriptory vlastností.

V nich můžeme novému objektu poskytnout další vlastnosti, například:

let zvíře = {
  žere: true
};

let králík = Object.create(zvíře, {
  skáče: {
    value: true
  }
});

alert(králík.skáče); // true

Deskriptory jsou ve stejném formátu, jaký byl popsán v kapitole Přepínače a deskriptory vlastností.

Pomocí Object.create můžeme provádÄ›t klonování objektů, které je silnÄ›jší než kopírování vlastností v cyklu for..in:

let klon = Object.create(
  Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj)
);

Toto volání vytvoří opravdu pÅ™esnou kopii obj, včetnÄ› vÅ¡ech vlastností: enumerovatelných i neenumerovatelných, datových vlastností i setterů a getterů – se vším a navíc se správným [[Prototype]].

Krátká historie

Způsobů, jak pracovat s [[Prototype]], existuje velké množství. Jak k tomu doÅ¡lo a proč?

Je tomu tak z historických důvodů.

Prototypová dědičnost byla v jazyce obsažena již od jeho začátků, ale způsoby, jak s ní manipulovat, se s časem vyvíjely.

• Vlastnost konstruktoru "prototype" fungovala již od pradávných časů. Je to nejstarší způsob, jak vytvářet objekty se zadaným prototypem.
• PozdÄ›ji, v roce 2012, se ve standardu objevila metoda Object.create, která poskytla možnost vytvářet objekty se zadaným prototypem, ale neposkytla možnost jej načítat nebo nastavovat. NÄ›které prohlížeče tedy implementovaly nestandardní přístupovou vlastnost __proto__, která umožňovala uživateli kdykoli načítat nebo nastavovat prototyp, aby poskytly vývojářům vÄ›tší flexibilitu.
• PozdÄ›ji, v roce 2015, byly do standardu pÅ™idány metody Object.setPrototypeOf a Object.getPrototypeOf, které poskytují stejnou funkcionalitu jako __proto__. Jelikož __proto__ bylo implementováno de facto vÅ¡ude, bylo tak trochu zavrženo a dostalo se do Přílohy B standardu, což znamená, že pro jiná než prohlížečová prostÅ™edí není povinné.
• PozdÄ›ji, v roce 2022, bylo oficiálnÄ› umožnÄ›no používat __proto__ v objektových literálech {...} (pÅ™esunuto z Přílohy B), ale ne jako getter/setter obj.__proto__ (stále v Příloze B).

Proč bylo __proto__ nahrazeno funkcemi getPrototypeOf/setPrototypeOf?

Proč bylo __proto__ částečnÄ› rehabilitováno a jeho použití dovoleno v {...}, ale ne jako getter/setter?

To je zajímavá otázka, která od nás vyžaduje, abychom pochopili, proč je __proto__ Å¡patné.

Brzy se dozvíme odpověď.

„Velmi plané“ objekty

Jak víme, objekty můžeme používat jako asociativní pole k ukládání dvojic klíč/hodnota.

…Pokud se do nÄ›j vÅ¡ak pokusíme uložit uživatelem poskytnuté klíče (například slovník s uživatelskými vstupy), uvidíme zajímavou závadu: vÅ¡echny klíče fungují správnÄ› až na "__proto__".

Ověřte si to na příkladu:

let obj = {};

let klíč = prompt("Jaký je klíč?", "__proto__");
obj[klíč] = "nějaká hodnota";

alert(obj[klíč]); // [object Object], ne "nějaká hodnota"!

Když zde uživatel zadá __proto__, pÅ™iÅ™azení na řádku 4 je ignorováno!

To může být pro nevývojáře jistÄ› pÅ™ekvapením, ale my bychom tomu mÄ›li rozumÄ›t. Vlastnost __proto__ je speciální: musí to být buď objekt, nebo null. ŘetÄ›zec nemůže být prototypem. Z tohoto důvodu je pÅ™iÅ™azení Å™etÄ›zce do __proto__ ignorováno.

Takové chování jsme vÅ¡ak nezamýšleli implementovat, že? Chceme ukládat dvojice klíč/hodnota a klíč jménem "__proto__" nebyl správnÄ› uložen. Takže je to chyba!

Zde důsledky nejsou hrozivé. V jiných případech vÅ¡ak můžeme do obj pÅ™iÅ™azovat objekty místo Å™etÄ›zců a pak se prototyp zcela jistÄ› zmÄ›ní. Výsledkem bude, že se bÄ›h skriptu pokazí naprosto nečekanými způsoby.

Co je horší – vývojáři o takové možnosti většinou vůbec nepřemýšlejí. To činí takové chyby obtížně zaznamenatelnými a dokonce způsobuje zranitelnost, zvláště když je JavaScript použit na straně serveru.

Nečekané vÄ›ci se mohou dít i tehdy, když pÅ™iÅ™azujeme do obj.toString, protože je to vestavÄ›ná objektová metoda.

Jak se můžeme tomuto problému vyhnout?

Za prvé, místo planých objektů můžeme k ukládání použít Map, pak bude vÅ¡echno v pořádku:

let mapa = new Map();

let klíč = prompt("Jaký je klíč?", "__proto__");
mapa.set(klíč, "nějaká hodnota");

alert(mapa.get(klíč)); // "nějaká hodnota" (jak jsme zamýšleli)

…AvÅ¡ak syntaxe Object je často lákavÄ›jší, protože je stručnÄ›jší.

Naštěstí můžeme použít objekty, protože autoři jazyka na tento problém mysleli už před dlouhou dobou.

Jak víme, __proto__ není vlastnost objektu, ale přístupová vlastnost Object.prototype:

Jestliže je tedy obj.__proto__ čtena nebo nastavována, z prototypu objektu se volá odpovídající getter či setter a ten [[Prototype]] načte nebo nastaví.

Jak bylo Å™ečeno na začátku této sekce tutoriálu: __proto__ je způsob přístupu k [[Prototype]], není to samotný [[Prototype]].

Jestliže tedy zamýšlíme používat objekt jako asociativní pole a takovým problémům se vyhnout, můžeme to udělat malým trikem:

let obj = Object.create(null);
// or: obj = { __proto__: null }

let klíč = prompt("Jaký je klíč?", "__proto__");
obj[klíč] = "nějaká hodnota";

alert(obj[klíč]); // "nějaká hodnota"

Object.create(null) vytvoří prázdný objekt bez prototypu ([[Prototype]] je null):

Pro __proto__ tedy nebude zdÄ›dÄ›n žádný getter/setter. Nyní se bude zpracovávat jako běžná datová vlastnost, takže uvedený příklad bude fungovat správnÄ›.

Takové objekty můžeme nazývat „velmi plané“ nebo „čistÄ› slovníkové“ objekty, protože jsou jeÅ¡tÄ› jednodušší než obvyklý planý objekt {...}.

Nevýhodou je, že takový objekt postrádá veÅ¡keré vestavÄ›né objektové metody, napÅ™. toString:

let obj = Object.create(null);

alert(obj); // Chyba (není toString)

…To je však u asociativních polí zpravidla dobře.

VÅ¡imnÄ›te si, že vÄ›tÅ¡ina metod vztahujících se k objektům jsou Object.něco(...), napÅ™. Object.keys(obj) – nejsou v prototypu, takže budou na takových objektech fungovat:

let čínskýSlovník = Object.create(null);
čínskýSlovník.ahoj = "你好";
čínskýSlovník.sbohem = "再见";

alert(Object.keys(čínskýSlovník)); // ahoj,sbohem

Shrnutí

• K vytvoÅ™ení objektu se zadaným prototypem použijeme:

  • literální syntaxi: { __proto__: ... }, která umožňuje specifikovat více vlastností,
  • nebo Object.create(proto[, deskriptory]), která umožňuje specifikovat deskriptory vlastností.

  Metoda Object.create poskytuje snadný způsob, jak vytvoÅ™it mÄ›lkou kopii objektu se vÅ¡emi deskriptory:

  let klon = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));

• Moderní metody pro načtení a nastavení prototypu jsou:

  • Object.getPrototypeOf(obj) – vrátí [[Prototype]] objektu obj (totéž jako getter __proto__).
  • Object.setPrototypeOf(obj, proto) – nastaví [[Prototype]] objektu obj na hodnotu proto (totéž jako setter __proto__).

• Načtení a nastavení prototypu pomocí vestavÄ›ného getteru/setteru __proto__ se nedoporučuje a nyní je ve specifikaci obsaženo v Příloze B.

• Uvedli jsme i objekty bez prototypů, vytvoÅ™ené pomocí Object.create(null) nebo {__proto__: null}.

  Tyto objekty se používají jako slovníky, aby do nich bylo možné uložit jakékoli klíče (třeba i vygenerované uživatelem).

  NormálnÄ› objekty dÄ›dí z Object.prototype vestavÄ›né metody a getter/setter __proto__, což znamená, že odpovídající klíče jsou „obsazeny“, a může to způsobit vedlejší efekty. Je-li prototyp null, objekty jsou skutečnÄ› prázdné.