Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / JavaScript

Function.prototype a syntaxe konstruktoru třídy

Rozlište prototypový řetězec funkce od vlastnosti `.prototype` používané pro instance a zjistěte, jak při dědění spolu souvisejí `new`, `constructor` a `super()`.

Verze: ECMAScript 2024 and the current web platform; runtime support varies

Syntaxe

function C(value) {
  this.value = value;
}
C.prototype.read = function () {
  return this.value;
};
const instance = new C(1);

Function.prototype
Object.getPrototypeOf(C)
C.prototype
Object.getPrototypeOf(instance)

class Base {
  constructor(value) {
    this.value = value;
  }
  read() {
    return this.value;
  }
}
class Derived extends Base {
  constructor(value) {
    super(value);
    this.ready = true;
  }
}
const derived = new Derived(2);

Function.prototype je vestavěný funkční objekt, z něhož funkce dědí metody jako call, apply a bind. Je přímým prototypem běžné funkce deklarované pomocí function a třídy bez extends. Volání Function.prototype() vrátí undefined, ale new Function.prototype() vyvolá TypeError.

C.prototype je něco jiného: jde o vlastní vlastnost běžné konstruktorové funkce nebo třídy C. Je-li její hodnotou objekt, new C(...) jej běžně použije jako prototyp instance. Toto spojení ověříte pomocí Object.getPrototypeOf(instance). Konstruktor ale může výslovně vrátit jiný objekt. Přidáním .prototype ke šipkové funkci nezískáte možnost použít ji s new.

Uvnitř class inicializuje constructor(...) { ... } instanci, obvykle přiřazením hodnot do vlastností přes this. Veřejné metody instancí, například read(), jsou na C.prototype, metody static na C. Na rozdíl od běžné funkce vyvolá přímé volání třídy jako C(...) chybu TypeError. Nahrazení .prototype u běžné funkce nezmění prototyp existujících instancí. U třídy není tato vlastnost zapisovatelná, ale samotný objekt prototypu lze stále měnit.

V class Derived extends Base dědí Derived z Base a Derived.prototype z Base.prototype. V explicitním konstruktoru odvozené třídy zavolejte super(...) před použitím this; dřívější použití vyvolá ReferenceError. Jestliže vrátíte přímo objekt bez použití this, můžete super() vynechat. Vynecháte-li celý konstruktor odvozené třídy, výchozí konstruktor předá argumenty dál.

Příklady

{
  function Legacy(name) {
    this.name = name;
  }
  Legacy.prototype.read = function () {
    return this.name;
  };

  class Modern {
    constructor(name) {
      this.name = name;
    }
    read() {
      return this.name;
    }
  }

  const a = new Legacy('Ada');
  const b = new Modern('Lin');
  const prototypeOf = Object.getPrototypeOf;
  const descriptor = Object.getOwnPropertyDescriptor;
  console.log(`${prototypeOf(Legacy) === Function.prototype} ${prototypeOf(Modern) === Function.prototype}`);
  console.log(`${prototypeOf(a) === Legacy.prototype} ${prototypeOf(b) === Modern.prototype}`);
  console.log(`${a.read()} ${b.read()}`);
  console.log(`${descriptor(Legacy, 'prototype').writable} ${descriptor(Modern, 'prototype').writable}`);
  try {
    Modern('Lin');
  } catch (error) {
    console.log(error.name);
  }
}

Výsledek

true true
true true
Ada Lin
true false
TypeError

Spusťte celý blok v konzoli s podporou syntaxe `class`. První dva řádky porovnávají prototypy konstruktorů a instancí; poslední řádek ukazuje název chyby nezávisle na znění její zprávy.

Související lekce

  • JavaScript · Lekce 32 · Pokročilá · Verze: 4

Zdroje