Array的方法

一、轉換方法

——此方法不會對原數組產生影響。所有對象都有toLocaleString()、toString()、valueOf()方法。

toString(); 返回以逗號拼接的字符串。
toLocaleString(); 返回本地格式的字符串。
valueOf(); 返回的還是數組。
join(); 返回按傳入符號分割的字符串。

1、toString()和valueOf()

var arr1 = ["hi", "hello"];
console.log(arr1.toString()); //返回hi,hello
console.log(typeof arr1.toString()); //返回string

console.log(arr1.valueOf()); //返回原數組
console.log(typeof arr1.valueOf()); //返回object

2、toLocaleString()

oLocaleString()方法經常返回和toString()、valueOf()方法一樣的值。不同的是：不會被默認調用；日期有一定的影響。

var arr1 = ["hi", "hello", new Date()];

document.write(arr1.toString());

document.write(arr1.valueOf());

document.write(arr1.toLocaleString());
//返回結果如下：
hi,hello,Sat Nov 28 2015 23:42:12 GMT+0800 (中國標準時間)
hi,hello,Sat Nov 28 2015 23:42:12 GMT+0800 (中國標準時間)
hi,hello,2015/11/28 下午11:42:12 —— 本地格式區域字符串

其中，toLocaleString()獲取的是本地電腦上的時間

3、join()

接受一個參數（分割符），傳入null或undefined時一空格分割。默認使用逗號分隔。

    var arr1 = ["hi", "hello", new Date()];

    document.write(arr1.join("/"));
    //返回hi/hello/Sat Nov 28 2015 23:52:47 GMT+0800 (中國標準時間)
    document.write(typeof arr1.join("/")); //返回string

    document.write(arr1);
    //返回hi,hello,Sat Nov 28 2015 23:52:47 GMT+0800 (中國標準時間)

二、棧方法

ECMAScript數組也提供了一種讓數組的行爲類似於其他數據結構的方法。具體來說，數組可以表現的像棧一樣，後者是一種可以限制插入和刪除項的數據結構。
棧是一種LIFO（Last-In-First-Out先進後出）的數據結構，也就是最新添加的像最早被移除。而棧中項的插入（叫做推入）和移除（叫做彈出），只發生在一個位置——棧的頂部。ECMScript爲數組專門提供了push()和pop()方法，以便實現類似棧的行爲。

push()；可以接收任意數量的參數，把它們逐個添加到數組末尾，並返回修改後的數組的長度。
pop()；從數組末尾移除最後一項，減少數組的length值，然後返回移除的項。

1、push()

    -----例：-----
    var arr = ["red"];
    var arr1 = ["blue", "yellow"];

    console.log(arr.push("blue", "yellow")); //3
    console.log(arr); //["red", "blue", "yellow"]

    console.log(arr.push(arr1)); //2
    console.log(arr); //["red", Array[2]]

push()插入數組時，該數組被當做一個元素插入，因此不管該數組中有多少了元素都只佔一個長度。

2、pop()

-----例：-----
var arr = ["haha", "hehe"];

console.log(arr.pop()); //hehe
console.log(arr.length); //1

三、隊列方法

棧數據結構的訪問規則時LIFO（先進後出），而隊列數據結構的訪問規則是FIFO（First-In-First-Out先進先出）。隊列在列表的末端添加項，從列表的前端移除項。實現這一操作的素組方法是unshift()和shift()。

unshift()；在數組前端添加任意個項並返回新數組的長度。 ——【IE7-unshift()方法總是返回undefined而不是新數組的長度】
shift()；移除數組中的第一個項並返回該項。

1、unshift()

    -----例：-----
    var arr = ["red"];
    var arr1 = ["blue", "yellow"];

    console.log(arr.unshift("blue", "yellow")); //3
    console.log(arr); //["blue", "yellow", "red"]

    console.log(arr.unshift(arr1)); //2
    console.log(arr); //[Array[2], "red"]

unshift()方法同push()方法一樣，插入數組時，該數組被當做一個元素插入，因此不管該數組中有多少了元素都只佔一個長度。

2、shift()

-----例：-----
var arr = ["haha", "hehe"];

console.log(arr.shift()); //haha
console.log(arr.length); //1

四、排序方法

reverse()；反轉數組項的順序。（reverse反向）
sort()；按升序/降序排列數組項，返回排序後的數組。
冒泡算法

1、revers()

    -----例：-----
    var arr = ["red", "blue", "yellow"];

    document.write(arr.reverse()); //yellow,blue,red

    document.write("<br />");
    document.write(arr); //yellow,blue,red

2、sort()

爲了實現排序，sort()方法會調用每個數組項的toString()轉型方法，然後比較的到的字符串，以確定如何排序。即使數組中的每一項都是數值，sort()方法比較的也是字符串。

    -----例：-----
    var arr = [0, 1, 5, 10, 15];
    console.log(arr.sort());
    console.log(arr); 
    //都返回： [0, 1, 10, 15, 5]

此處比較的是數值字符串(即比較字符串對應的字符編碼值)。

因爲sort()方法在很多情況下不是最佳方案，因此sort()方法可以接收一個比較函數作爲參數，以便我們指定哪個值位於哪個值的前面。

如果爲 sortfunction 參數提供了一個函數，那麼該函數必須返回下列值之一：

負值，如果所傳遞的第一個參數比第二個參數小。

零，如果兩個參數相等。

正值，如果第一個參數比第二個參數大。

升序：

-----例：-----
function compare(value1, value2) {
    if(value1 < value2) { //如果第一個參數比第二個參數大
        return -1;
    } else if(value1 > value2) {
        return 1;
    } else {
        return 0;
    }
}

var arr = [0, 1, 5, 10, 15];
console.log(arr.sort(compare));
console.log(arr); 
//都返回： [0, 1, 5, 10, 15]

反序（只需將返回值正負更換一下就可以了）——如果要反序用revers()方法更加方便：

-----例：-----
function compare(value1, value2) {
    if(value1 < value2) { //如果第一個參數比第二個參數大
        return 1;
    } else if(value1 > value2) {
        return -1;
    } else {
        return 0;
    }
}

var arr = [0, 1, 5, 10, 15];
console.log(arr.sort(compare)); 
console.log(arr);
//都返回： [15, 10, 5, 1, 0]

排序——冒泡算法

-----例：-----
var arr = [0, 1, 5, 10, 15];
for(var i = 0; i < arr.length - 1; i++) {
    for(var j = i + 1; j < arr.length; j++) {
        if(arr[i] < arr[j]) {
            var a = arr[i];  //定義一箇中間變量
            arr[i] = arr[j];
            arr[j] = a;
        }
    }
}
console.log(arr); //[15, 10, 5, 1, 0]
/*---------數組元素按從大到小排序---此方法爲冒泡排序---------------------------*/

五、操作方法

concat()；複製原數組，將其與傳入參數/數組合並並返回合併後的新數組。 ——【並不會對原數組產生影響】
slice(startINDEX, endINDEX)；返回截取原數組中的項。 ——【並不會對原數組產生影響】
splice()；返回被刪除的元素。有三種功能：刪除、插入、替換。主要用途是向數組的中部插入項。

1、concat()

在沒有傳遞參數的情況下，它只是複製當前數組並返回副本;

如果傳遞的參數是一個或多個數組，則該方法會將這些數組中的每一項都添加到結果數組中;

如果傳遞的值不是數組，這些值就會被簡單的添加到結果數組的末尾。——有先後順序

-----例：-----
var arr = ["red", "yellow"];

console.log(arr.concat("blue"));
console.log(arr);
//返回結果如下： 
["red", "yellow", "blue", "gray", "123"]
["red", "yellow"]


console.log(arr.concat(["blue", "gray"], ["123"]));
console.log(arr);
//返回結果如下： 
["red", "yellow", "blue"]
["red", "yellow"]

2、slice()

如果只用一個參數，則返回從該參數指定位置開始到當前數組末尾的所有的項；

如果有兩個數組，則返回起始位置和結束位置之間的項——但不包含結束位置的項。

-----例：-----
var arr = ["red", "yellow", "blue", "gray", "back"];

console.log(arr.slice(1));
console.log(arr.slice(1, 3));
console.log(arr);
//返回結果如下：
["yellow", "blue", "gray", "back"]
["yellow", "blue"]
["red", "yellow", "blue", "gray", "back"]

如果傳遞的參數中有一個是負數，則用數組長度加上該數來確定相應的位置（反向取得該索引位置的項）。

-----例：-----
var arr = ["red", "yellow", "blue", "gray", "back"];

console.log(arr.slice(-3, -1));  
//等價於console.log(arr.slice(2, 4));
console.log(arr);
//返回結果如下：
["blue", "gray"]
["red", "yellow", "blue", "gray", "back"]

如果傳遞的參數，結束位置小於起始位置，則返回空數組。

3、splice()

接收三個參數：

1、起始位置；
2、刪除個數；

3、插入/替換元素或數組。

插入的元素索引值爲splice方法的第一個參數對應的索引位置。

-----例：-----
var arr = ["red", "yellow", "blue", "gray", "back"];
console.log(arr.splice(3, 0,"hhhhhhhhhhhhhhhh"));  //插入的元素的索引爲3
console.log(arr);
//返回結果如下：
[]
["red", "yellow", "blue", "hhhhhhhhhhhhhhhh", "gray", "back"]

六、索引位置方法

indexOf(item, startIndex)；返回需查找的項第一次出現的索引值；
lastIndexOf(item, startIndex)；返回需查找的項最後一次出現的索引值；

都接受兩個參數：要查找的項和（可選的）表示查找七點位置的索引。當沒有找到所匹配的項時，返回值爲-1。
```
例：
var arr = [1, 2, 3, 1, 4, 5];
console.log(arr.indexOf(1)); //0
console.log(arr.lastIndexOf(1)); //3
```
在將需查找的項與數組中的每一項相比較時，會使用全等操作符（===）相比較。也就是說，要求查找的項必須全等。

console.log(arr.indexOf(“1”)); //-1

七、迭代方法

every(fn); 函數fn對每一項都返回true，則返回true；
some(fn); 函數fn對某一項返回true，則返回true；
filter(fn); 返回函數fn返回值爲true的所有項組成的數組；
map(fn); 返回每次函數調用的結果組成的數組。
forEach(fn); 對數組中的每一項運行給定函數。此方法沒有返回值。

1、every()方法：

    var arr = [1, 2, 3, 1, 4, 5];
    var everyItem1 = arr.every(function(item, index, arr) {
        return (item < 3);
    }); 
    var everyItem2 = arr.every(function(item, index, arr) {
        return (item < 10);
    }); 
    console.log(everyItem1); //false
    console.log(everyItem2); //true
    console.log(arr); //[1, 2, 3, 1, 4, 5]

2、some()方法：

    var arr = [1, 2, 3, 1, 4, 5];
    var someItem1 = arr.some(function(item, index, arr) {
        return (item < 3);
    }); 
    var someItem2 = arr.some(function(item, index, arr) {
        return (item < 10);
    }); 
    console.log(someItem1); //true
    console.log(someItem2); //true
    console.log(arr); //[1, 2, 3, 1, 4, 5]

3、filter()方法：

    var arr = [1, 2, 3, 1, 4, 5];
    var filterItem1 = arr.filter(function(item, index, arr) {
        return (item < 3);
    }); 
    var filterItem2 = arr.filter(function(item, index, arr) {
        return (item < 10);
    }); 
    console.log(filterItem1); //[1, 2, 1]
    console.log(filterItem2); //[1, 2, 3, 1, 4, 5]
    console.log(arr); //[1, 2, 3, 1, 4, 5]

此方法適合查詢某些符合條件的所有數組項。

4、map()方法：

    var arr = [1, 2, 3, 1, 4, 5];
    var mapItem1 = arr.map(function(item, index, arr) {
        return (item * 3);
    }); 
    console.log(mapItem1); //[3, 6, 9, 3, 12, 15]
    console.log(arr); //[1, 2, 3, 1, 4, 5]

此方法適合創建包含的項與另一個數組一一對應。

5、forEach()方法：

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

8、歸併方法

obj.reduce(callback, startIndex); 從數組第一項開始遍歷數組；
obj.reduceRight(callback, startIndex); 從數組最後一項開始遍歷數組。

兩個方法都會迭代數組中所有的項，然後構建一個最終返回的值。reduce()和reduceRight()最大的區別也是唯一的區別就是遍歷數組項的順序不同。

兩個方法都接收兩個參數：一個是在每一項上調用的函數，另一個是作爲歸併基礎的起始索引值（爲可選參數）。

傳入的函數callback接收四個參數：前一個值；當前值；項的索引值，數組對象。這個函數返回的任何值都會作爲第一個參數自動傳給下一項。第一次迭代發生在數組的第二項上，因此第一個參數是數組的第一項，第二個參數就是數組的第二項。

1、obj.reduce();

var obj = [1, 2, 3, 4, 5];
var sum = obj.reduce(function(prev, next, index, arr) {
    console.log(index);
    return prev + next
});
console.log(sum);
//1
//2
//3
//4
//15

第一次執行回調函數，傳入的prev是1，next是2。第二次，prev是3（1+2），next是3（數組的第三項）。

obj.reduceRight(); 順序相反

var obj = [1, 2, 3, 4, 5];
var sum = obj.reduceRight(function(prev, next, index, arr) {
    console.log(index);
    return prev + next
});
console.log(sum);
//3
//2
//1
//0
//15

第一次執行回調函數，傳入的prev是5，next是4。第二次，prev是9（5+4），next是3（數組的倒數第三項）。