最近看了一下developer.mozilla.org里的东西，发现它为Array对象添加了不少generic method，赶得上Prototype的热心程度。
indexOf
返回元素在数组的索引，没有则返回-1。与string的indexOf方法差不多。
如果其他浏览器没有实现此方法，可以用以下代码实现兼容：
01.Array.prototype.indexOf = function(el, start) {
02. var start = start || 0;
03. for ( var i=0; i < this.length; ++i ) {
04. if ( this[i] === el ) {
05. return i;
06. }
07. }
08. return -1;
09.};
1.var array = [2, 5, 9];
2.var index = array.indexOf(2);
3.// index is 0
4.index = array.indexOf(7);
5.// index is -1
lastIndexOf
与string的lastIndexOf方法差不多。
如果其他浏览器没有实现此方法，可以用以下代码实现兼容：
01.Array.prototype.lastIndexOf = function(el, start) {
02. var start = start || this.length;
03. if ( start >= this.length ) {
04. start = this.length;
05. }
06. if ( start < 0 ) {
07. start = this.length + start;
08. }
09. for ( var i=start; i >= 0; --i ) {
10. if ( this[i] === el ) {
11. return i;
12. }
13. }
14. return -1;
15.};
forEach
各类库中都实现相似的each方法。
如果其他浏览器没有实现此方法，可以用以下代码实现兼容：
1.Array.prototype.forEach = function(fn, thisObj) {
2. var scope = thisObj || window;
3. for ( var i=0, j=this.length; i < j; ++i ) {
4. fn.call(scope, this[i], i, this);
5. }
6.};
1.function printElt(element, index, array) {
2. print("[" + index + "] is " + element); // assumes print is already defined
3.}
4.[2, 5, 9].forEach(printElt);
5.// Prints:
6.// [0] is 2
7.// [1] is 5
8.// [2] is 9
every
如果数组中的每个元素都能通过给定的函数的测试，则返回true，反之false。换言之给定的函数也一定要返回true与false
如果其他浏览器没有实现此方法，可以用以下代码实现兼容：
01.Array.prototype.every = function(fn, thisObj) {
02. var scope = thisObj || window;
03. for ( var i=0, j=this.length; i < j; ++i ) {
04. if ( !fn.call(scope, this[i], i, this) ) {
05. return false;
06. }
07. }
08. return true;
09.};
01.function isBigEnough(element, index, array) {
02. return (element >= 10);
03.}
04.var passed = [12, 5, 8, 130, 44].every(isBigEnough);
05.console.log(passed)
06.// passed is false
07.passed = [12, 54, 18, 130, 44].every(isBigEnough);
08.// passed is true
09.console.log(passed)
some
类似every函数，但只要有一个通过给定函数的测试就返回true。
如果其他浏览器没有实现此方法，可以用以下代码实现兼容：
01.Array.prototype.some = function(fn, thisObj) {
02. var scope = thisObj || window;
03. for ( var i=0, j=this.length; i < j; ++i ) {
04. if ( fn.call(scope, this[i], i, this) ) {
05. return true;
06. }
07. }
08. return false;
09.};
1.function isBigEnough(element, index, array) {
2. return (element >= 10);
3.}
4.var passed = [2, 5, 8, 1, 4].some(isBigEnough);
5.// passed is false
6.passed = [12, 5, 8, 1, 4].some(isBigEnough);
7.// passed is true
filter
把符合条件的元素放到一个新数组中返回。
如果其他浏览器没有实现此方法，可以用以下代码实现兼容：
01.Array.prototype.filter = function(fn, thisObj) {
02. var scope = thisObj || window;
03. var a = [];
04. for ( var i=0, j=this.length; i < j; ++i ) {
05. if ( !fn.call(scope, this[i], i, this) ) {
06. continue;
07. }
08. a.push(this[i]);
09. }
10. return a;
11.};
1.function isBigEnough(element, index, array) {
2. return (element <= 10);
3.}
4.var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
map
让数组中的每一个元素调用给定的函数，然后把得到的结果放到新数组中返回。。
如果其他浏览器没有实现此方法，可以用以下代码实现兼容：
1.Array.prototype.map = function(fn, thisObj) {
2. var scope = thisObj || window;
3. var a = [];
4. for ( var i=0, j=this.length; i < j; ++i ) {
5. a.push(fn.call(scope, this[i], i, this));
6. }
7. return a;
8.};
1.var numbers = [1, 4, 9];
2.var roots = numbers.map(Math.sqrt);
3.// roots is now [1, 2, 3]
4.// numbers is still [1, 4, 9]
reduce
让数组元素依次调用给定函数，最后返回一个值，换言之给定函数一定要用返回值。
如果其他浏览器没有实现此方法，可以用以下代码实现兼容：
01.Array.prototype.reduce = function(fun /*, initial*/)
02.{
03. var len = this.length >>> 0;
04. if (typeof fun != "function")
05. throw new TypeError();
06. if (len == 0 && arguments.length == 1)
07. throw new TypeError();
08. var i = 0;
09. if (arguments.length >= 2){
10. var rv = arguments[1];
11. } else{
12. do{
13. if (i in this){
14. rv = this[i++];
15. break;
16. }
17. if (++i >= len)
18. throw new TypeError();
19. }while (true);
20. }
21.
22. for (; i < len; i++){
23. if (i in this)
24. rv = fun.call(null, rv, this[i], i, this);
25. }
26. return rv;
27.};
1.var total = [0, 1, 2, 3].reduce(function(a, b){ return a + b; });
2.// total == 6