JavaScript数组扩展方法实现指南

indexOf与lastIndexOf：查找元素索引

该方法用于返回指定元素在数组中的索引位置，若未找到则返回-1。其功能与字符串类型的indexOf方法类似。

若目标浏览器环境未原生支持此方法，可通过以下代码进行兼容处理：

 
Array.prototype.indexOf = function(el, start) {
var start = start || 0;
for ( var i=0; i < this.length; ++i ) {
if ( this[i] === el ) {
return i;
        } 
    } 
return -1;
}; 
var array = [2, 5, 9];
var index = array.indexOf(2);
// index is 0
index = array.indexOf(7);
// index is -1

该方法的逻辑与字符串类型的lastIndexOf方法相似。

若其他浏览器环境未实现此功能，可采用以下代码进行兼容：

 
Array.prototype.indexOf = function(el, start) {
var start = start || 0;
for ( var i=0; i < this.length; ++i ) {
if ( this[i] === el ) {
return i;
        } 
    } 
return -1;
}; 

forEach：遍历数组元素

许多JavaScript库中都实现了类似的each方法。

若其他浏览器未实现此方法，可使用以下代码进行兼容：

 
Array.prototype.forEach = function(fn, thisObj) {
var scope = thisObj || window;
for ( var i=0, j=this.length; i < j; ++i ) {
fn.call(scope, this[i], i, this);
    } 
}; 
function printElt(element, index, array) {
print("[" + index + "] is " + element); // assumes print is already defined
} 
[2, 5, 9].forEach(printElt);
// Prints:
// [0] is 2
// [1] is 5
// [2] is 9

every与some：条件测试

若数组中所有元素均能通过给定函数的测试，则返回true；否则返回false。这意味着给定的回调函数必须返回布尔值。

若其他浏览器未实现此方法，可使用以下代码进行兼容：

 
Array.prototype.every = function(fn, thisObj) {
var scope = thisObj || window;
for ( var i=0, j=this.length; i < j; ++i ) {
if ( !fn.call(scope, this[i], i, this) ) {
return false;
        } 
    } 
return true;
}; 
function isBigEnough(element, index, array) {
return (element <= 10);
} 
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// passed is false
passed = [12, 54, 18, 130, 44].every(isBigEnough);
// passed is true

与every函数类似，但只要有一个元素通过给定函数的测试，即返回true。

若其他浏览器未实现此方法，可使用以下代码进行兼容：

 
Array.prototype.some = function(fn, thisObj) {
var scope = thisObj || window;
for ( var i=0, j=this.length; i < j; ++i ) {
if ( fn.call(scope, this[i], i, this) ) {
return true;
        } 
    } 
return false;
}; 
function isBigEnough(element, index, array) {
return (element >= 10);
} 
var passed = [2, 5, 8, 1, 4].some(isBigEnough);
// passed is false
passed = [12, 5, 8, 1, 4].some(isBigEnough);
// passed is true

filter与map：数组过滤与映射

该方法将符合条件的元素提取出来，放入一个新数组并返回。

若其他浏览器未实现此方法，可使用以下代码进行兼容：

 
Array.prototype.filter = function(fn, thisObj) {
var scope = thisObj || window;
var a = [];
for ( var i=0, j=this.length; i < j; ++i ) {
if ( !fn.call(scope, this[i], i, this) ) {
continue;
        } 
a.push(this[i]);
    } 
return a;
}; 
function isBigEnough(element, index, array) {
return (element <= 10);
} 
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);

该方法使数组中的每个元素调用给定函数，并将每次调用的结果收集到新数组中返回。

若其他浏览器未实现此方法，可使用以下代码进行兼容：

 
Array.prototype.map = function(fn, thisObj) {
var scope = thisObj || window;
var a = [];
for ( var i=0, j=this.length; i < j; ++i ) {
a.push(fn.call(scope, this[i], i, this));
    } 
return a;
}; 
<div id="highlighter_240589">
var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
// roots is now [1, 2, 3]
// numbers is still [1, 4, 9]

reduce：数组归并计算

该方法使数组元素依次调用给定函数，并最终返回一个累积值。因此，给定的回调函数必须包含返回值。

若其他浏览器未实现此方法，可使用以下代码进行兼容：

 
Array.prototype.reduce = function(fun /*, initial*/)
{ 
var len = this.length >>> 0;
if (typeof fun != "function")
throw new TypeError();
if (len == 0 && arguments.length == 1)
throw new TypeError();
var i = 0;
if (arguments.length >= 2){
var rv = arguments[1];
} else{
do{
if (i in this){
rv = this[i++];
break;
      } 
if (++i >= len)
throw new TypeError();
}while (true);
  } 
for (; i < len; i++){
if (i in this)
rv = fun.call(null, rv, this[i], i, this);
  } 
return rv;
}; 

 
var total = [0, 1, 2, 3].reduce(function(a, b){ return a + b; });
// total == 6