LINUX SOFTWARE

V minulém článku o JAK sem shrnul základní metody a mechanismy, které se hodí každému programátorovi. JavaScript je však jazyk objektový, a i JAK je na objektech založen. Jak se s objekty a jejich třídy pracuje, se pokusím vysvětlit v tomto článku.

20.1.2011 00:00 | Ondřej Tůma | přečteno 12310×

Základním prvkem knihovny je tedy objekt, instance třídy, resp. instance JAK třídy. JAK totiž obsahuje obal pro definici a aplikaci tříd, obdobně, jako to známe z ostatních objektových jazyků např. C++. Můžete tak například snadno definovat třídu, která dědí z jiné, nebo je singltonem. První příklad ukazuje jak se takové třídy za pomocí knihovny JAK vytvářejí:

var Terorist = JAK.ClassMaker.makeClass({
    NAME: "Terorist",
    VERSION: "1.0"
});

Terorist._counter = 0;          // statická proměnná
Terorist.prototype.name = '';   // dynamická proměnná

Terorist.prototype.$constructor = function(name){
    this.name = name;
    Terorist._counter++;
}

Terorist.prototype.$destructor = function(){
    Terorist._counter--;
}

Terorist.prototype.talk = function(){
    document.write('My name is ' + this.name + ', the ' + this.constructor.NAME);
    document.write('. I kill you !
');
}
            
var ahmed = new Terorist('Ahmed');
ahmed.talk();

document.write('Count of Terorists: '+ Terorist._counter+'
');

V kódu je vidět jak se definuje třída pomocí ClassMakeru. Parametry metody makeClass jsou název a verze třídy. Na dalším řádku je vidět definice statické proměnné. Ta je sdílená napříč všemi instancemi třídy. Dynamická proměnná (tedy lokální pro každou instanci) je přístupná přes operátor this. Přístup do paměti takové proměnné je copy_on_write, tedy vlastní skutečná kopie proměnné nastává až v okamžiku zápisu přes this. Zápis přes Trida.prototype mění statickou hodnotu, kterou uvidí všechny instance které si nevytvořili vlastní kopii zápisem.

Na definici metod není nic zvláštního až na specifickou metodu $constructor. Ta je volána po vytvoření objektu automaticky, pokud existuje. Lze definovat i metodu $destructor, nicméně ta se při mazání automaticky nevolá, a musíte si jí tak zavolat sami. Ostatní kód již netřeba komentovat, vytvoříme instanci třídy a zavoláme její metodu.

Dědičnost

Třída která je potomkem jiné třídy se v JAKu definuje neskutečně jednoduše, prostě metodě makeClass dáte ještě jeden parametr EXTEND a v něm uvedete rodiče oné třídy. Možnosti dědičnosti jsou však značně omezené a to také naznačuje následující ukázka.

var Bomberman = JAK.ClassMaker.makeClass({
    NAME: "Bomberman",
    VERSION: "1.0",
    EXTEND: Terorist
});

Bomberman.prototype.$constructor = function(name, bombs){
    this.$super(name);
    this.bombs = bombs;
}

Bomberman.prototype.$destructor = function(){
    document.write('BUM !!
');
    this.$super();
}

Bomberman.prototype.talk = function(){
    Terorist.prototype.talk.call(this);     // totéž co this.$super();
    document.write('I kill you all with my ' + this.bombs + ' bombs.
')
}

var mushafa = new Bomberman('Mushafa', 2);
mushafa.talk();
mushafa.$destructor();

Pokud chceme aby nějaká metoda potomka třídy zavolala metodu svého rodiče, provedeme to metodou $super. Ta volá metodu rodiče, která je stejná jako metoda, ve které je $super použito, viz definice metod $constructor. Je jí tím pádem možné volat pouze v metodě se stejným názvem, tedy v takové, kterou přepisujeme.

Dále můžeme dědit jen z jedné třídy, ale ta může být potomkem jiné. V případě že potřebujete volat libovolnou metodu libovolného předka, použijete zápis Prarodic.prototype.method.call(this, arg1, arg2...), tak jak je to v ukázce u metody Bomberman.prototype.talk. No a nakonec nemůžeme definovat metody, které je možné přepsat.

Interface

Další způsob jak rozšířit funkčnost nějaké třídy je použít Interface (rozhraní). Těch může být uvedeno více, a v případě konfliktů v názvech metod vyhrává metoda z posledního uvedeného rozhraní. Kombinace rodiče (EXTEND) a rozhraní (IMPLEMENT) není vyloučena, což ukazuje i následující kód.

var Hacker = JAK.ClassMaker.makeInterface({
    NAME: "Hacker",
    VERSION: "1.0",
});

Hacker.prototype.hack = function(){
    document.write('Your PC is hacked, cha cha chaaaa!
');
};

var eTerorist = JAK.ClassMaker.makeClass({
    NAME: "eTerororist",
    VERSION: "1.0",
    EXTEND: Terorist,
    IMPLEMENT: [Hacker]
});

var farad = new eTerorist('Farad');
farad.hack();
farad.talk();

Singleton a Statická třída

Zvláštní lahůdkou na závěr jsou třídy typu Singleton a Statické třídy, jejich význam je obdobný. Instance těchto tříd nelze vytvořit neboť Singleton může být jen jeden, a statická třída nemůže být dynamická :) Než tuto stručnou a prostou informaci doplním ukázkou kódu, nesmím zapomenou upozornit na to, že i tyto typy tříd se v knihovně sami objevují. Které to jsou neprozradím a uložím to laskavému čtenáři za domácí úkol k prozkoumání.

// Singleton
var BinLadin = JAK.ClassMaker.makeSingleton({
    NAME: "BinLadin",
    VERSION: "1.0",
    EXTEND: Terorist
});

BinLadin.prototype.$constructor = function(){
    this.$super(this.constructor.NAME);
}

BinLadin.prototype.talk = function(){
    document.write("I'm "+this.name+'. ');
    document.write('America must be destroyed !!
');
}

BinLadin.getInstance().talk();
//new BinLadin();    // končí s chybou

// Static
var Zero = JAK.ClassMaker.makeStatic({
    NAME: "Zero",
    VERSION: "1.0"
});

Zero.value = 0;

console.log(Zero.value);
//new Zero();             // končí s chybou

Závěrem

JavaScript je jazyk objektový, ale jeho přístup k objektům je zcela jiný, než v ostatních objektových jazycích. Knihovna JAK se pokouší tyto rozdíly minimalizovat a jazyk samotný rozšířit. Za sebe mohu říct že se jí to daří a přibližuje webové programování ostatním programátorům, kteří jsou zvyklí na jiné objektové jazyky.

JAK na třídy

Dědičnost

Interface

Singleton a Statická třída

Závěrem