Mootools “si estende” plus “Utensili”

Question

Mi piace scrivere il mio codice sottile e sexy (sul lato delle prestazioni e della memoria), io sto usando Mootools e chiedevo se stavo usando nel modo corretto, anche tu mi possa aiutare dicendomi come testare il mio codice per trovare le risposte che sto cercando per la mia auto.

//First we create a class like so:

var FirstClass = new Class {(
   'someFunc': function() { /* do stuff */ }
})

//Now this class uses first class with "Implements"

var SecondClass = new Class ({
   'Implements': [FirstClass, SomeOtherClass, SomeOtherOtherClass],
   'iAlsoDoStuff': function() {/*do stuff */}
})

// finally the class that Extends second class
var ThirdClass = new Class ({
   'Extends': SecondClass,
   'takeOverTheWorld': function() {/*code to win lottery */}
})

Come faccio a sapere se ogni volta secondClass è esteso si pretende molto fare una nuova copia delle classi implementate? La ragione per cui sto facendo quello che sto facendo qui sopra è quello di estendere secondClass per ogni classe che ne ha bisogno -. Così facendo in modo statico, mentre la seconda classe non può estendere più di una classe così sto usando Utensili

Answer 1

Finalmente ho avuto la mia risposta sul gruppo Mootools google, ho pensato di aggiornarlo qui nel caso in cui qualcuno trova interesse in esso.

http://groups.google.com/group/mootools : agli utenti / browse_thread / thread / 5aec78813fa51cc1

Buon divertimento! Romano

Answer 2

  

La differenza principale tra estende e Utensili è che implementare le modifiche il prototipo della classe, mentre Estendere crea una copia. Questo significa che se si implementa un cambiamento in una classe tutte le istanze di quella classe erediteranno che il cambiamento subito, mentre se si utilizza Estendere allora tutte le istanze esistenti rimarranno le stesse.

Questa è una citazione dal mootorial, check it out. http://mootorial.com/wiki/mootorial/02-class /#implement-vs.-extend

Per quanto riguarda il test - mi piacerebbe molto consigliamo di costruire alcuni casi campione con classi ninja e la loro messa a http: / /www.jsfiddle.net - poi chiedere qualche consiglio analitica o la lista MooTools posta su Google o su IRC (irc.freenode.net # mootools), quindi non sembrano avere molti successi della squadra di MooTools nucleo . Idealmente, si desidera parlare con qualcuno come Aaron newton, Arian, cpojer o rpflo:)

---

Aggiornamento: Ho anche bloggato su questo, ma mi sbagliavo. V'è semplicemente una differenza nell'ordine in cui mutators come Extends e Implements sono portati in. È possibile implementare ed estendere, ma è necessario dichiarare Estende prima per farlo funzionare.

Per saperne di più qui: http: //fragged.org/mootools-pattern-fun-class-implements-extends-at-the-same-time_1359.html

---

Aggiorna si è visto, ci sono alcuni casi in cui questo è utile. Qui è il problema:

var ninja = new Class({
    kill: function() {
        alert("kill!");
    }
});

var human = new Class({
    initialize: function(){
        alert("i r human!");
    }
});

var badass = new Class({
    Implements: [ninja],
    Extends: human,
    initialize: function() {
        alert("i r badass and.. ");
        this.parent();
        this.kill();
    }
});

new badass(); // i r badass, i r human, this.kill is not a function exception.

... semplicemente non funziona. Hai bisogno di classe umana per implementare ninja , invece, e di classe cazzuto per estendere semplicemente umana . A parte l'effetto collaterale di esseri umani ottenere un nuovo metodo kill (che può o non può sapere), vorrà dire che tosta sarà in grado di utilizzare .kill così come chiamata sul suo umana controllante diretta.

Perché non riscrivere le cose nel modo desiderato e w / o complicazioni? Perché si può essere estendendo una classe nativa come Request.JSONP e poi decidere di mixin una nuova classe di archiviazione nella vostra una estesa. La vera storia ... In entrambi i casi, non si può avere il lusso di refactoring alcune classi disponibili.

Un modello interessante per superare questo (si pensi alla classe umana tua request.jsonp, definita altrove) - se si desidera aggiungere più metodi e proprietà per la classe che si sta estendendo, ma non avete intenzione di riutilizzare la classe intermedia ( ninja):

human.implement(new new Class({
    kill: function() {
        alert("kill!");
    }
}));

var badass = new Class({
    Extends: human,
    initialize: function() {
        alert("i r badass and.. ");
        this.parent();
        this.kill();
    }
});

new badass(); // // i r badass, i r human, kill!

Probabilmente, si può solo fare human.implement({ method: function }); ma una classe può essere molto di più.

Se si vuole avere un punto di riferimento salvato la classe ninja per altri usi, quanto sopra sarebbe sarebbe lo stesso di questo (se si prevede di riutilizzare il mixin):

var ninja new Class({
    kill: function() {
        alert("kill!");
    }
});

human.implement(new ninja); 
// this is what differs from say - instantiation + shared inherited properties.
// also, a constructor will work.
// the alternative would just do:
// human.prototype.kill = function() { alert("kill"); }

var badass = new Class({
    Extends: human,
    initialize: function() {
        alert("i r badass and.. ");
        this.parent();
        this.kill();
    }
});

new badass(); // // i r badass, i r human, kill!

Spero che questo aiuti qualcuno. Ecco un esempio pratico in cui mi rivolgo Request.JSONP con una classe di storage supplementare come mixin: http: // jsfiddle. net / Dimitar / YacZe /

Answer 3

estende e attrezzature sono molto ben testato dagli sviluppatori Mootools stessi. Infatti l'intera suite di test che usano è disponibile su anutron / MooTools-unittester . Non è necessario essere testare funzionalità di base del framework, il suo fatto per voi (e fatto molto bene anche).

Io suggerirei di avere una buona lettura su ciò che estendere e implementare fanno sul MooTools documenti, sito web, clientcide mootorial, ecc.

Quanti oggetti stai creando a proposito? Se la sua non è un numero enorme, allora la memoria ecc non dovrebbe essere un grosso problema, anche se stava creando gli oggetti in maniera pesante di memoria. Questo potrebbe essere l'ottimizzazione prematura?