Jakie są twoje ulubione prototypy obiektów macierzystych Mootools/Prototype?

Question

Nas Mootoolers i Prototypers (co niewielu jest na tej stronie) zwykle noszą poręczny zestaw narzędzi z funkcjami, które stworzyliśmy (lub wypożyczyliśmy), które implementujemy na natywnych obiektach javascript, aby nasze życie było trochę łatwiejsze. Chciałem uzyskać listę bardzo pomocnych prototypowych funkcji, ale tylko te, które są implementowane na rodzimych obiektach (np. String.implement({... w mootools).

Jakie są twoje ulubione produkty?

---

PS: I obejmował zarówno Mootools i prototyp w funkcji pisemnej do jednej biblioteki jest całkiem łatwo przeniesiony do innego.

PPS: Znam argumenty za/przeciw prototypowaniu rodzimych obiektów javascript, wolałbym omijać tę dyskusję tutaj.

Answer 1

Oto niektóre z moich ulubionych funkcji mootools.

Funkcje łańcuchowe

String.implement({ 

    //easy way to test if a string contains characters (input.value.isEmpty()) 
    isEmpty : function() { 
     return (!this.test(/\w+/)); 
    }, 

    //add ellipses if string length > len 
    ellipse : function(len) { 
     return (this.length > len) ? this.substr(0, len) + "..." : this; 
    }, 

    //finds all indexOf occurrences 
    indexesOf : function(val) { 
     var from = 0; 
     var indexes = []; 
     while (0 <= from && from < this.length) { 
      var idx = this.indexOf(val, from); 
      if (idx >= 0) { 
       indexes.push(idx); 
      } else { 
       break; 
      } 
      from = idx+1; 
     } 
     return indexes; 
    } 
}); 

funkcje tablicowe

Array.implement({ 

    //compare two arrays to see if they are identical 
    compare : function(arr, strict) { 
     strict = strict || false; 
     if (this.length != arr.length)   return false; 

     for (var i = 0; i < this.length; i++) { 
      if ($type(this[i]) == "array") { 
       if (!this[i].compare(arr[i])) return false; 
      } 
      if (strict) { 
       if (this[i] !== arr[i])  return false; 
      } else { 
       if (this[i] != arr[i])  return false; 
      } 
     } 
     return true; 
    }, 

    //remove non-unique array values 
    unique : function() { 
     for(var i = 0; i< this.length; i++) { 
      var keys = this.indexesOf(this[i]); 
      while (keys.length > 1) { 
       this.splice(keys.pop(), 1); 
      } 
     } 
     return this; 
    }, 

    //same as array.unshift, except returns array instead of count 
    //good for using inline... array.lpush('value').doSomethingElse() 
    lpush : function() { 
     for (var i = arguments.length -1 ; i >= 0; i--){ 
      this.unshift(arguments[i]); 
     } 
     return this; 
    }, 

    //get all indexes of an item in an array 
    indexesOf : function(item) { 
     var ret = []; 
     for (var i = 0; i < this.length; i++) { 
      if (this[i] == item) ret.push(i); 
     } 
     return ret; 
    } 
}); 

Answer 2

//taken from http://prototype.lighthouseapp.com/projects/8886/tickets/351-new-swap-method-for-elements 
Element.addMethods({ 
    swap: (function() { 
    if ('swapNode' in document.documentElement) 
     return function(element, other) { 
     return $(element).swapNode($(other)); 
     }; 
    return function(element, other) { 
     element = $(element); 
     other = $(other); 
     var next = other.nextSibling, parent = other.parentNode; 
     element.parentNode.replaceChild(other, element); 
     return parent.insertBefore(element, next); 
    }; 
    })() 
}); 


// extend the array object to support indexed insertions 
// submitted at http://prototype.lighthouseapp.com/projects/8886-prototype/tickets/356-arrayinsert 
Array.prototype.insert=function(element,where) { 
    var slice1=this.slice(0,where); 
    var slice2=this.slice(where); 

    return new Array.concat(slice1,element,slice2); 
}; 


//extend the array object to support searching thrtough indexed arrays 
// if returnIndex is true, then return the keyName, else return the value from that cell 
Array.prototype.nextValue=function(startIndex,returnIndex) { 
    for(var i=startIndex+1;i<this.length;i++){ 
     if(this[i]){ 
      return (returnIndex?i:this[i]); 
     } 
    } 
    return null; 
}; 


//extend the array object to support searching thrtough indexed arrays 
// if returnIndex is true, then return the keyName, else return the value from that cell 
Array.prototype.prevValue=function(startIndex,returnIndex) { 
    for(var i=startIndex-1;i>=0;i--){ 
     if(this[i]){ 
      return (returnIndex?i:this[i]); 
     } 
    } 
    return null; 
}; 

Answer 3

ja naprawdę nie rozwija się ani prototyp ani Mootools, ale myślę, że następujące rzeczy byłyby użyteczne w tych ram także.

Zamiennik dla rodzimej Math.round() że trwa opcjonalny drugi parametr, który określa Precyzja:

Math.round(3.1415, 2); // 3.14 

nie() metoda funkcji, aby uzyskać zanegowane predykat:

var even = function(x){ return x % 2 === 0; }; 
var odd = even.not(); 
even(2); // true 
odd(2); // false 

Ale najbardziej przydatne rzeczy to te, które chciałbym dodać do Object.prototype, jeśli byłby to bezpieczny sposób, aby to zrobić, więc zamiast tego mam pewne funkcje globalne do iterowania nad obiektem nieruchomości.

objMap() podobny Array.map(), ale dla obiektów:

// returns {a:2, b:4, c:6} 
objMap({a:1, b:2, c:3}, function(value) { 
    return value*2; 
}); 

objValues ​​() i objKeys() uzyskać tablicę nazw własności lub wartości Address:

objValues({a:1, b:2, c:3}); // [1, 2, 3] 
objKeys({a:1, b:2, c:3}); // ["a", "b", "c"] 

I oczywiście objReduce() zrobić niemal wszystko można sobie wyobrazić ...

Szczegóły realizacji zostały pozostawione jako ćwiczenie dla czytelnika :-)

Answer 4

Lubię jak nieruchomość jest sprawdzana przed stworzeniem, aby uniknąć nadpisania właściwości natywnych.

if(!Array.prototype.indexOf) { 
    Array.prototype.indexOf = function(){ ... }; 
} 

Answer 5

kontynuowałem na co tj111 rozpoczął, oto mój mały dodatek:

Array.implement({ 
    //calculate the sum of all integers 
    sum: function() { 
     var sum = this.reduce(function(a, b) { 
      return a + b; 
     }); 
     return sum; 
    } 
});