Ukryte funkcje MooTools

Question

Jakie są ukryte lub niejasne cechy MooTools, o których powinien wiedzieć każdy programista MooTools?

Jedna cecha na odpowiedź, proszę.

Answer 1

Istnieje wiele funkcji, które można wykorzystać, jeśli odczytać kodu źródłowego, chociaż oficjalna linia: if it's not in the documentation, it is not in the api and it's not supported so do not base your code around it as it may change

Mając na uwadze powyższe, istnieje kilka rzeczy, które naprawdę mogą być bardzo użyteczne. Jeden z moich ulubionych nieudokumentowanych funkcji to:

Przypisane elementy mają uid

żadnego elementu, który albo jest utworzony lub jest przekazywany za pomocą wybieraka, zostaje przydzielony właściwość uid, który jest przyrostowe i niepowtarzalny . Od wersji MooTools 1.4.2 można to odczytać tylko przez Slick.uidOf(node), a nie przez stary element attr .uid. Możesz teraz użyć nowej właściwości uniqueNumber dowolnego obiektu elementu MooTools.

Jak to się dzieje? Na początek, przechowywanie elementów. Opiera się on na identyfikatorze Uid jako kluczu w obiekcie Storage wewnątrz zamknięcia, który będzie miał wszystko, co posiadasz dla tego elementu.

element.store('foo', 'bar'); 

przekłada się:

Storage[Slick.uidOf(element)].foo = 'bar'; 

i

element.retrieve('foo'); // getter of the storage key 
element.eliminate('foo'); // delete Storage[Slick.uidOf(element)].foo 

Inicjowanie przechowywanie zostały utworzone na zewnątrz elementu, na przykład, poprzez var foo = document.createElement('div') a nie konstruktor element

Slick.uidOf(foo); // makes it compatible with Storage 

// same as: 
document.id(foo); 

Th pliki przechowywane przez strukturę do pamięci masowej obejmują również wszystkie wywołania zwrotne events, instancje validators wystąpienia (animacja, przekształcanie itp.) i tak dalej.

Co możesz zrobić, znając UID elementów? Otóż ​​klonowanie elementu NIE powoduje przechowywania lub zdarzeń elementu. Możesz teraz napisać nowy prototyp Element.cloneWithStorage, który również skopiuje wszystkie zapisane wartości, które są przydatne do punktu - instancje odwołujące się do konkretnego elementu (np. Fx.Tween) będą nadal odwoływać się do starego elementu, więc może nieoczekiwane wyniki. Może to być przydatne w przenoszeniu własnej pamięci masowej, ale wszystko, czego potrzebujesz, to podobna metoda, która zapisze to, co masz zapisane, i pozwoli ci ją sklonować.

Przykład bagażu przebicie danych Kolejnym elementem jest:

var foo = new Element('div'), 
    uid = foo.uniqueNumber; 

foo.store('foo', 'foo only'); 

var bar = new Element('div'); 

console.log(bar.retrieve('foo')); // null 

bar.uniqueNumber = uid; // force overwrite of uid to the other el 

console.log(bar.retrieve('foo')); // foo only - OH NOES 

console.log(Object.keys(foo)); // ["uniqueNumber"] - oh dear. enumerable! 

Answer 2

Function.prototype.protect jest może mniej znane ładny.

Służy do chroniły metod w klasach:

var Foo = new Class({ 

    fooify: function(){ 
     console.log('can\'t touch me'); 
    }.protect(), 

    barify: function(){ 
     this.fooify(); 
    } 

}); 

var foo = new Foo(); 
foo.fooify(); // throws error 
foo.barify(); // logs "can't touch me" 

Osobiście nie używam go bardzo często, ale może być przydatna w niektórych przypadkach.

Answer 3

Function.prototype.overloadGetter i Function.prototype.overloadSetter

Zobacz ten post: What does MooTools' Function.prototype.overloadSetter() do?

Answer 4

Class mutatorów

MooTools ma wspaniałą funkcję, która pozwala na tworzenie własnych mutatorów klasie. Na przykład, aby dodać rejestrator do którego odwołuje się poszczególne metody klasy, można zrobić:

// define the mutator as 'Monitor', use as Mointor: ['methodname', 'method2'...] 
Class.Mutators.Monitor = function(methods){ 
    if (!this.prototype.initialize) this.implement('initialize', function(){}); 
    return Array.from(methods).concat(this.prototype.Monitor || []); 
}; 

Class.Mutators.initialize = function(initialize){ 
    return function(){ 
     Array.from(this.Monitor).each(function(name){ 
      var original = this[name]; 
      if (original) this[name] = function() { 
       console.log("[LOG] " + name, "[SCOPE]:", this, "[ARGS]", arguments); 
       original.apply(this, arguments); 
      } 
     }, this); 
     return initialize.apply(this, arguments); 
    }; 
}; 

a następnie w klasie:

var foo = new Class({ 

    Monitor: 'bar', 

    initialize: function() { 
     this.bar("mootools"); 
    }, 

    bar: function(what) { 
     alert(what); 
    } 

}); 

var f = new foo(); 
f.bar.call({hi:"there from a custom scope"}, "scope 2"); 

Spróbuj jsfiddle: http://jsfiddle.net/BMsZ7/2/

Ten mały klejnot ma odegrałem zasadniczą rolę w złapaniu problemów związanych z wyścigowymi problemami wyścigowymi wewnątrz aplikacji asynchronicznej HUUUGE, które w przeciwnym razie byłyby trudniejsze do wyśledzenia.

Answer 5

polecam czytanie doskonałą serię Up the Moo Herd przez Mark Obcena, autor Pro Javascript With MooTools     :)

Answer 6

jeden z moich ulubionych cech, które się później dowiedziałem, ale szkoda Wiedziałem od początku - pseudos zdarzeń, zwłaszcza :once.

Zobacz http://mootools.net/docs/more/Class/Events.Pseudos#Pseudos:once