Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / JavaScript

Function.prototype a syntax konštruktora triedy

Rozlíšte prototypový reťazec funkcie od vlastnosti `.prototype` používanej pre inštancie a zistite, ako pri dedení spolu súvisia `new`, `constructor` a `super()`.

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

Syntax

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 vstavaný funkčný objekt, z ktorého funkcie dedia metódy ako call, apply a bind. Je priamym prototypom bežnej funkcie deklarovanej pomocou function a triedy bez extends. Volanie Function.prototype() vráti undefined, no new Function.prototype() vyvolá TypeError.

C.prototype je niečo iné: je to vlastná vlastnosť bežnej konštruktorovej funkcie alebo triedy C. Ak je jej hodnotou objekt, new C(...) ho bežne použije ako prototyp inštancie. Toto prepojenie overíte cez Object.getPrototypeOf(instance). Konštruktor však môže výslovne vrátiť iný objekt. Pridaním .prototype k šípkovej funkcii nezískate možnosť použiť ju s new.

Vnútri class inicializuje constructor(...) { ... } inštanciu, zvyčajne priradením hodnôt do vlastností cez this. Verejné metódy inštancií, napríklad read(), sú na C.prototype, metódy static na C. Na rozdiel od bežnej funkcie priame volanie triedy ako C(...) vyvolá TypeError. Nahradením .prototype bežnej funkcie sa nezmení prototyp existujúcich inštancií. V triede do tejto vlastnosti nemožno zapisovať, no samotný objekt prototypu sa stále dá upravovať.

V class Derived extends Base dedí Derived z Base a Derived.prototype z Base.prototype. V explicitnom konštruktore odvodenej triedy zavolajte super(...) pred použitím this; skoršie použitie vyvolá ReferenceError. Ak priamo vrátite objekt bez použitia this, môžete super() vynechať. Ak vynecháte celý konštruktor odvodenej triedy, predvolený konštruktor posunie argumenty ďalej.

Prí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ýsledok

true true
true true
Ada Lin
true false
TypeError

Spustite celý blok v konzole s podporou syntaxe `class`. Prvé dva riadky porovnávajú prototypy konštruktorov a inštancií; posledný ukazuje názov chyby nezávisle od znenia jej hlásenia.

Súvisiace lekcie

  • JavaScript · Lekcia 32 · Pokročilá · Verzia: 4

Zdroje