Konstruktor, operátor „new“

Obvyklá syntaxe {...} nám umožňuje vytvoÅ™it jeden objekt. ÄŒasto vÅ¡ak potÅ™ebujeme vytvoÅ™it mnoho podobných objektů, napÅ™. více uživatelů, položek menu a podobnÄ›.

To můžeme učinit pomocí konstruktorů a operátoru "new".

Konstruktor

Konstruktory jsou z technického hlediska obvyklé funkce. Platí pro ně však dvě konvence:

1. Jejich název začíná velkým písmenem.
2. MÄ›ly by být volány jen pomocí operátoru „new“.

Například:

function Uživatel(jméno) {
  this.jméno = jméno;
  this.jeSprávce = false;
}

let uživatel = new Uživatel("Kuba");

alert(uživatel.jméno); // Kuba
alert(uživatel.jeSprávce); // false

Když je funkce volána pomocí new, provedou se následující kroky:

1. Vytvoří se nový prázdný objekt a pÅ™iÅ™adí se do this.
2. Vykoná se tÄ›lo funkce. To obvykle modifikuje this, do nÄ›hož pÅ™idá nové vlastnosti.
3. Vrátí se hodnota this.

Jinými slovy, new Uživatel(...) udÄ›lá nÄ›co jako:

function Uživatel(jméno) {
  // this = {};  (implicitnÄ›)

  // přidá vlastnosti do this
  this.jméno = jméno;
  this.jeSprávce = false;

  // return this;  (implicitnÄ›)
}

Takže let uživatel = new Uživatel("Kuba") vydá stejný výsledek jako:

let uživatel = {
  jméno: "Kuba",
  jeSprávce: false
};

Když nyní budeme chtít vytvoÅ™it jiné uživatele, můžeme volat new Uživatel("Anna"), new Uživatel("Alice") a tak dále. Je to mnohem kratší než pokaždé používat literály a je to i snadno čitelné.

To je hlavní smysl konstruktorů – implementovat opakovaně použitelný kód pro vytváření objektů.

Znovu poznamenejme, že technicky může být libovolná funkce (s výjimkou Å¡ipkových funkcí, jelikož ty nemají this) použita jako konstruktor. Může být volána pomocí new a pak se vykoná výše uvedený algoritmus. „Velké první písmeno“ je obvyklá úmluva, aby bylo zÅ™ejmé, že funkce má být volána pomocí new.

// vytvoříme funkci a okamžitě ji zavoláme pomocí new
let uživatel = new function() {
  this.jméno = "Jan";
  this.jeSprávce = false;

  // ...další kód pro vytváření uživatele
  // možná složitá logika a příkazy
  // lokální proměnné atd.
};

Test režimu konstruktoru: new.target

UvnitÅ™ funkce můžeme ověřit, zda byla volána pomocí new nebo bez nÄ›j, pomocí speciální vlastnosti new.target.

Ta je pÅ™i běžném volání undefined, ale pokud je funkce volána pomocí new, je rovna této funkci:

function Uživatel() {
  alert(new.target);
}

// bez „new“:
Uživatel(); // undefined

// s „new“:
new Uživatel(); // function Uživatel { ... }

Můžeme ji použít uvnitÅ™ funkce, abychom se dozvÄ›dÄ›li, zda byla volána „v režimu konstruktoru“ pomocí new nebo „v běžném režimu“ bez nÄ›j.

Můžeme také funkci pÅ™imÄ›t, aby pÅ™i volání pomocí new a pÅ™i běžném volání provádÄ›la totéž, například takto:

function Uživatel(jméno) {
  if (!new.target) { // pokud mě spustíte bez new
    return new Uživatel(jméno); // ...přidám new pro vás
  }

  this.jméno = jméno;
}

let jan = Uživatel("Jan"); // přesměruje volání na new Uživatel
alert(jan.jméno); // Jan

Tento přístup se nÄ›kdy používá v knihovnách, aby byla syntaxe flexibilnÄ›jší. Lidé pak mohou volat funkci s new nebo bez nÄ›j a funkce pokaždé funguje.

PravdÄ›podobnÄ› vÅ¡ak není dobré používat jej vÅ¡ude, protože bez uvedení new je trochu ménÄ› zÅ™ejmé, co se dÄ›je. Když je uvedeno new, vÅ¡ichni víme, že se vytváří nový objekt.

Návrat z konstruktorů

Konstruktory obvykle nemají příkaz return. Jejich úkolem je zapsat vÅ¡echno potÅ™ebné do this a to se pak automaticky stane výsledkem.

Jestliže vÅ¡ak je příkaz return přítomen, platí jednoduché pravidlo:

• Je-li return volán s objektem, vrátí se namísto this tento objekt.
• Je-li return volán s primitivem, tento primitiv se ignoruje.

Jinými slovy, return s objektem vrátí onen objekt, ve vÅ¡ech ostatních případech se vrátí this.

Například zde return pÅ™episuje this vrácením objektu:

function VelkýUživatel() {

  this.jméno = "Jan";

  return { jméno: "Godzilla" };  // <-- vrátí tento objekt
}

alert( new VelkýUživatel().jméno );  // Godzilla, získali jsme onen objekt

A zde je příklad s prázdným return (nebo za nÄ›j můžeme umístit primitiv, na tom nezáleží):

function MalýUživatel() {

  this.jméno = "Jan";

  return; // <-- vrátí this
}

alert( new MalýUživatel().jméno );  // Jan

Konstruktory obvykle příkaz return neobsahují. Speciální chování s vracením objektů zde zmiňujeme zejména pro úplnost.

let uživatel = new Uživatel; // <-- bez závorek
// totéž jako
let uživatel = new Uživatel();

Metody v konstruktoru

Používání konstruktorů k vytváření objektů nám dává velké množství flexibility. Konstruktor může mít parametry, které definují, jak objekt zkonstruovat a co do něj uložit.

SamozÅ™ejmÄ› do this můžeme pÅ™idávat nejen vlastnosti, ale také metody.

Například níže uvedené new Uživatel(jméno) vytvoří objekt se zadanou vlastností jméno a metodou řekniAhoj:

function Uživatel(jméno) {
  this.jméno = jméno;

  this.řekniAhoj = function() {
    alert( "Jmenuji se: " + this.jméno );
  };
}

let jan = new Uživatel("Jan");

jan.řekniAhoj(); // Jmenuji se: Jan

/*
jan = {
   jméno: "Jan",
   řekniAhoj: function() { ... }
}
*/

K vytváření složitých objektů existuje i pokročilejší syntaxe – třídy, kterou probereme později.

Shrnutí

• Konstruktory jsou obvyklé funkce, avÅ¡ak panuje běžná úmluva, že jejich název by mÄ›l mít velké první písmeno.
• Konstruktory by mÄ›ly být volány jedinÄ› pomocí new. Takové volání způsobí, že se na začátku vytvoří prázdné this a to se pak na konci vrátí naplnÄ›né.

Konstruktory můžeme používat k vytváření více podobných objektů.

JavaScript poskytuje konstruktory pro mnoho vestavÄ›ných jazykových objektů: napÅ™. Date pro data, Set pro množiny a jiné, které máme v plánu prostudovat.