摘要：接收三個參數數組項的值，該項在數組中的位置，數組對象本身對數組中的每一項運行給定函數，如果該函數對任一項都返回則返回。對數組中的每一項運行給定函數，返回該函數會返回的項組成的數組。

ECMAScript數組的每一項可以保存任何類型的數據，可以是字符串、數值、對象、函數、數組等等。

創建數組基本方式有兩種，第一種是使用Array構造函數：

    var arr=new Array(1,2,3);

可以省略new操作符。

第二種方式是使用數組字面量表達法：

    var arr=[1,2,3];

使用數組字面量表達法時，不會調用Array構造函數。

toString()方法：返回由數組中的每個值得字符串形式拼接而成的一個以逗號分隔的字符串。

valueOf()方法；在數組中與toString()方法操作相同。

toLocaleString()方法：與前兩種方法不同的地方是，前兩種方法在調用的時候，為了取得每一項的值，調用的是每一項的toString()方法;而toLocaleString()方法在調用的時候，為了取得每一項的值，調用的是每一項的toLocaleString()方法。

push()方法：從尾部添加一個或多個參數。

    var arr=["a","b"];
    arr.push("c","d");
    alert(arr);       //a,b,c,d

pop()方法：從尾部刪除最后一項。

    var arr=["a","b"];
    arr.pop();
    alert(arr);       //a

shift()方法：從頭部刪除第一項。

    var arr=["a","b"];
    arr.shift();
    alert(arr);       //b

unshift()方法：從頭部添加一個或多個參數。

    var arr=["a","b"];
    arr.unshift("c","d");
    alert(arr);       //c,d,a,b

reverse()方法；反轉數組項的排序。

    var arr=[0,1,2,3,4];
    arr.reverse();
    alert(arr);            //4,3,2,1,0

sort()方法：按升序排列數組項——即最小的值位于最前，最大的值排在最后。

    var arr=[0,1,3,11,15];
    arr.sort();
    alert(arr);   //0,1,11,15,3

值得注意的是sort()方法會隱式調用toString()方法;所以它比較的是字符串，但是它可以接收一個比較函數作為參數：

    function compare(value1,value2){
        if(value1value2){
            return 1;
        }
        else{
            return 0;
        }
    }
    var arr=[0,1,3,11,15];
    arr.sort(compare);
    alert(arr)            //0,1,3,11,15

concat()方法：創建當前數組一個副本，然后將接收到的參數添加到這個副本的末尾，最后返回新構建的數組。

    var arr=[1,2];
    var arr2=arr.concat(1,[1,2]);
    alert(arr2);//1,2,1,1,2

如果參數是一或多個數組，則將這些數組中的每一項都添加到結果數組中。

slice()方法：基于當前數組中的一或多個項創建一個新數組?？梢越邮找换騼蓚€參數，即要返回的起始和結束位置(不包括結束位置項)。

    var arr=["a","b","c","d","e"];
    var arr2=arr.slice(1);
    var arr3=arr3.slice(1,4);
    alert(arr2);//b,c,d,e
    alert(arr3);//b,c,d

splice()方法：刪除，插入，替換。
1、刪除：指定兩個參數：要刪除的第一項的位置和要刪除的項數。

var arr=[1,2,3,4];
arr.splice(1,2);
alert(arr);//1,4

2、插入：指定3個參數：起始位置、0（要刪除的項數）、插入的項（可以任意多個項）。

var arr=["a","b","c"];
arr.splice(2,0,"d","e");
alert(arr);//a,b,d,e,c

3、替換：指定3個參數：起始位置、要刪除的項數、替換的項（可以任意多個項）。

var arr=["a","b","c"];
arr.splice(2,1,"d","e");
alert(arr);//a,b,d,e

indexOf()方法：從數組開頭向后查找項的位置，接收兩個參數：要查找的項和表示查找起點位置的索引（可選的）。

var arr=["a","b","c","d","e","d","c","b","a"];
alert(arr.indexOf("d"));//3
alert(arr.indexOf("d",4));//5

值得注意的是indexOf()方法一查找到符合條件的值，就會停止查找，所以只有一個參數d的時候即從0位置開始查找顯示位置是3，而在后面加一個位置索引4之后，也就是從e這個項開始向后查找，所以顯示5。

lastIndexOf()方法：從數組末尾向后查找項的位置，接收兩個參數：要查找的項和表示查找起點位置的索引（可選的）。

var arr=["a","b","c","d","e","d","c","b","a"];
alert(arr.lastIndexOf("d"));//5
alert(arr.lastIndexOf("d",4));//3

every()：對數組中的每一項運行給定函數，如果該函數對每一項都返回true,則返回true。接收三個參數：要在每一項上運行的函數，運行該函數的作用域對象（可選的）——影響this的值。

var arr=[1,2,3,4,5,4,3,2,1];
var everyResult=arr.every(function(item,index,array/*接收三個參數：數組項的值，該項在數組中的位置，數組對象本身*/){
    return (item>2);
});
alert(everyResult);//false

some()：對數組中的每一項運行給定函數，如果該函數對任一項都返回true,則返回true。

var arr=[1,2,3,4,5,4,3,2,1];
var someResult=arr.every(function(item,index,array){
    return (item>2);
});
alert(someResult);//true

filter()：對數組中的每一項運行給定函數，返回該函數會返回true的項組成的數組。

var arr=[1,2,3,4,5,4,3,2,1];
var filterResult=arr.filter(function(item,index,array){
    return (item>2);
});
alert(filterResult);//[3,4,5,4,3]

map()：對數組中的每一項運行給定函數，返回每次函數調用的結果組成的數組。

var arr=[1,2,3,4,5,4,3,2,1];
var mapResult=arr.map(function(item,index,array){
    return item*2;
});
alert(mapResult);//[2,4,6,8,10,8,6,4,2]

forEach()：對數組中的每一項運行給定函數，這個方法沒有返回值。

var arr=[1,2,3,4,5,4,3,2,1];
var forEachResult=arr.forEach(function(item,index,array){
    //執行某些操作
});

reduce(/*每一項上調用的函數*/，/*作為歸并基礎的初始值（可選的）*/);

    reduce(function(prev/*前一個值*/，cur/*當前值*/，index/*項的索引*/，array/*數組對象*/){},10/*可選的*/);

    var arr=[1,2,3,4,5];
    var sum=arr.reduce(function(prev,cur,index,array){
        return prev+cur;
    });
    alert(sum);//15

這個方法會迭代數組所有想項，也就是說對數組中的每一項給定一個函數，然后構建一個最終返回的值。從數組的第一項開始，逐個遍歷到最后。

歸并開始時，第一次迭代發生在數組的第二項上，也就是索引值為1，這時prev是1，cur是2。第二次迭代發生在數組的第三項上，也就是索引值為2，這時prev是3（因為此時已經發生過一次迭代，是前一次迭代1+2的結果），cur是3。這個過程會持續到把數組中的每一項都訪問一遍，最后返回結果。

但是如果傳入一個初始值，那就不一樣了：

    var arr=[1,2,3,4,5];
    var sum=arr.reduce(function(prev,cur,index,array){
        return prev+cur;
    }，20);
    alert(sum);//35

歸并開始時，第一次迭代發生在數組的第一項上，也就是索引值為0，這時prev是20，cur是1。

reduceRight()：與reduce()類似，只不過方向相反而已，除此之外，它們完全相同。

    var arr=[1,2,3,4,5];
    var sum=arr.reduceRight(function(prev,cur,index,array){
        return prev+cur;
    }，20);
    alert(sum);//35