Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / JavaScript

Function.prototype i składnia konstruktora klasy

Odróżnij prototyp samej funkcji od właściwości `.prototype` używanej do tworzenia instancji. Zobacz, jak `new`, `constructor` i `super()` łączą się z dziedziczeniem.

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

Składnia

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 to wbudowany obiekt funkcyjny, z którego funkcje dziedziczą m.in. call, apply i bind. Jest bezpośrednim prototypem zwykłej funkcji zadeklarowanej przez function i klasy bez extends. Wywołanie Function.prototype() zwraca undefined, ale new Function.prototype() zgłasza TypeError.

C.prototype to inna rzecz: własna właściwość zwykłej funkcji konstruktora lub klasy C. Jeśli jej wartość jest obiektem, to przy new C(...) domyślnie staje się on prototypem instancji. Sprawdzisz to przez Object.getPrototypeOf(instance). Konstruktor może jednak jawnie zwrócić inny obiekt. Samo dodanie .prototype do funkcji strzałkowej nie sprawi, że będzie można używać jej z new.

constructor(...) { ... } wewnątrz class inicjalizuje instancję, zwykle przez przypisania do this. Publiczne metody instancji, takie jak read(), trafiają na C.prototype, a metody static na C. Bezpośrednie wywołanie klasy jako C(...) zgłasza TypeError, w odróżnieniu od zwykłej funkcji. W zwykłej funkcji można zastąpić .prototype, ale nie zmieni to prototypu istniejących instancji. W klasie ta właściwość nie jest zapisywalna, choć sam obiekt prototypu można nadal modyfikować.

W class Derived extends Base to Derived dziedziczy z Base, a Derived.prototype z Base.prototype. W jawnym konstruktorze klasy pochodnej wywołaj super(...) przed użyciem this; wcześniejsze użycie zgłasza ReferenceError. Wyjątkiem jest bezpośredni zwrot obiektu bez użycia this, który pozwala pominąć super(). Jeśli pominiesz cały konstruktor klasy pochodnej, konstruktor domyślny przekaże argumenty dalej.

Przykłady

{
  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);
  }
}

Wynik

true true
true true
Ada Lin
true false
TypeError

Uruchom cały blok w konsoli obsługującej składnię `class`. Pierwsze dwa wiersze porównują prototypy konstruktorów i instancji, a ostatni pokazuje nazwę błędu bez polegania na treści jego komunikatu.

Powiązane lekcje

  • JavaScript · Lekcja 32 · Zaawansowany · Wersja: 4

Źródła