摘要：創建數組讀取和設置數組的值創建數組創建數組的基本方式有兩種使用構造函數使用數組字面量表示法對于第一種方法，如果知道數組要保存多少個項目，也可以給構造函數傳遞參數，比如要創建值為的數組操作符可以省略。也可以向構造函數傳遞包含的項。

除了Object 之外，Array 類型也是相當常用的類型了。ECMAScript 數組的每一項可以保存任何類型的數據。且數組大小也能夠動態調整的。

創建數組的基本方式有兩種：

使用Array 構造函數：var colors = new Array()；

使用數組字面量表示法；

對于第一種方法，如果知道數組要保存多少個項目，也可以給構造函數傳遞參數，比如要創建length 值為10 的數組：

var colors = Array(10);
//new 操作符可以省略。

也可以向Array 構造函數傳遞包含的項。如：

var colors = Array("yellow","red","green");

對于第二種方法，數組字面量由方括號表示，用逗號隔開。如：

var colors = [
    "red",
    "green",
    "blue"
]
console.log(colors); //["red", "green", "blue"]
var boys = [];
document.write(boys.length); //0

使用方括號和基于0 的數字索引。如：

var colors = [
    "red",
    "blue",
    "yellow"
]
document.write(colors[1]); //"blue" 訪問第二項
document.write(colors.length); //3 
colors[3] = "cc";
document.write(colors.length); //4 創建一個新的項
document.write(colors[3]); //"cc"

length屬性，數組的項數就保存在length 屬性中，這個屬性返回0 或更大的值。且該屬性可寫的，可以從數組的末尾移除或增加項。如：

var colors = [
    "red",
    "blue"
]
colors[colors.length] = "yellow";
console.log(colors); // ["red", "blue", "yellow"] 在末尾增加了一項"yellow"
colors.length = 2;
console.log(colors); // ["red", "blue"] 在末尾減少了一項
colors.length = 3;
console.log(colors); //["red", "blue", undefined × 1] 在末尾增加了一項undefined

利用length屬性，可以方便地在數組末尾添加新項，如：

var colors = ["red"];
colors[colors.length] = "yellow";

《js 高級程序設計》提到：
數組最多可以包含4 294 967 295 個項。

使用instanceof操作符：if (value instanceof Array) {}；

使用ECMAScript 5 新增的Array.isArray()方法：if (Array.isArray(value))；

檢測數組instanceof操作符的問題，在這里不深究。支持Array.isArray()方法的瀏覽器有IE9、FIrefox 4+、Safari 5+、Opera 10.5+和Chrome。

通常，用toString()方法會返回數組中每個值的字符串形式拼接而成的以逗號分隔開來的字符串；用valueOf()方法則仍然返回數組。

var colors = ["red","yellow"];
var color1 = colors.toString();
document.write(typeof color1); //string 使用toString() 方法，返回的是用逗號分割的字符串；

var color2 = colors.valueOf();
document.write(typeof color2); //object
console.log(color2) //使用valueOf() 方法，返回的仍然是數組;

另外，還可以使用toLocaleString()方法，如：

var person = {
    toLocaleString:function(){
        return "Oliver";
    },
    toString:function(){
        return "Troy";
    }
};
var age = {
    toLocaleString:function(){
        return "adult";
    },
    toString:function(){
        return "children";
    }
};
var people = [person,age];
document.write(people.toString()); //Troy,children 返回每個數組里面的每個對象的toString 返回的值
document.write(people.toLocaleString()); //Oliver,adult 返回每個數組里面的每個對象的toLocaleString 返回的值
document.write(people.valueOf()); //Troy,children
document.write(people.join(" is a ")); //Troy is a children 改變兩個數組鏈接起來的分隔符

可以使用join()方法來控制數組的連接符。

ECMAScript 數組可以表現的像棧一樣。棧是一種LIFO（Last-In-First—Out，后進先出），只發生在一個位置——棧的頂部。

有兩個方法push()和pop()方法。具體的來說，push()方法可以接收任意數量的參數，把它們逐個添加到數組的末尾，并返回修改后的數組的長度；pop()方法則可以從數組的末尾移除最后一項，減少數組的length 值，并返回移除的項。如：

添加項：

var array = [1,2,3,4];

console.log(array); //[1, 2, 3, 4] 目前該array 有4項

var count = array.push("str","34"); //末尾增加了一項"str"和一項"34"
console.log(count); //6 這時返回的長度增加2
console.log(array); //[1, 2, 3, 4, "str", "34"]
console.log(array.length); //6

減少項：

var array = [1,2,3,4];

console.log(array); //[1, 2, 3, 4] 目前該array 有4項

var count = array.pop();
console.log(count); //4 減少了一個"4"
console.log(array); //[1, 2, 3]

隊列數據結構的訪問規則是FIFO（First-In-First-Out），結合使用shift()和push()方法，可以像使用隊列一樣使用數組。shift()可以移除數組中的第一個項，并返回該項。如：

var array = [];
var count = array.push("1","2");
document.write(count);
document.write(array); //[1,2]

count = array.push("3");
document.write(count);
document.write(array); //[1,2,3]

var item = array.shift();
document.write(item); //1
document.write(array); //[2,3]

另外，還有一個叫unshift()方法，同時使用unshift()和pop()方法，可以從相反的方向來模擬隊列，即在前端添加項，末端移除項。如：

var array = [];
var count = array.unshift(1,2,3);
document.write(count); //3
document.write(array); //[1,2,3]

count = array.unshift(0);
document.write(count); //4
document.write(array); //[0,1,2,3]

item = array.pop();
document.write(item); //3
document.write(array); //[0,1,2]

需要注意的是：

shift()返回的是前端刪除的項的值；

unshift()返回的是前端增加后數組的長度；

pop()返回的是末端刪除的項的值；

push()返回的是末端增加后數組的長度。

總的來說就是“刪除返回項的值，增加則返回長度”

有兩個重排序方法：reverse()和sort()。

sort()方法按照升序排列數組項，如：

var array = [4321,3,43,"56",6543,32,65,765];
array.sort(); //3,32,43,4321,56,65,6543,765

亂七八糟，只比較了第一位數。

比較函數接收兩個參數，如果第一個參數應該位于第二個之前，則返回一個復數，如果兩個參數相等則返回0，如果第一個參數應該位于第二個參數后面，則返回一個正數。通常返回第二個參數減掉第一個參數的值就可以了（在數值類型或其valueOf()方法返回數值類型的對象類型的情況下）。如：

var array = [3,1,6,"10"];
array.sort(compare);

function compare(value1,value2){
    return value1 - value2; //如果value1 - value2 是正數，則說明value1 大于value2，value1 應該排在后面。為升序排列；
};

document.write(array); //[1,3,6,10]

如果想要降序排列，則修改一下compare函數成value2 - value1 就可以了。如：

var array = [3,1,6,"10"];
array.sort(compare);

function compare(value1,value2){
    return value2 - value1; //如果value2 - value1 是正數，則說明value2 大于value1，value1 應該排在后面。為降序排列；
};

document.write(array); //[10,6,3,1]

但是如果是任意類型，則不能使用這種方法。而應當對參數進行比較。如：

var array = ["Oliver","Troy",{name:"troy"},"Alice"];
array = array.sort(compare);
document.write(array); //Alice,Oliver,Troy,[object Object]

function compare(x,y){
    if(x > y){
        return 1;
    }else if(x < y){
        return -1;
    }else{
        return 0;
    }
}

或者：

var array = ["Oliver","Troy",{name:"troy"},"Alice"];
array = array.sort(compare);
document.write(array); //Alice,Oliver,Troy,[object Object]

function compare(x,y){
    if(x < y){
        return 1;
    }else if(x > y){
        return -1;
    }else{
        return 0;
    }
}

如果只是想翻轉原來數組的順序，使用reverse()方法就行了，如：

var array = [3,1,6,"10"];
array.reverse();
document.write(array); //10,6,1,3

concat()方法，主要作用就是復制當前的數組并返回副本。如：（不影響原始數組）

var array = ["abc",123,{name:"Oliver"}];
var newArray = array.concat("abc",[123,32,{age:18}]);
document.write(newArray); // abc,123,[object Object],abc,123,32,[object Object]

slice()方法，主要作用是基于當前數組中的一個或多個項創建的一個新數組。如：（不影響原始數組）

var array = ["a","b","c","d"];
var newArray = array.slice(2);
document.write(newArray); //c,d
newArray = array.slice(1,2);
document.write(newArray); //b

如果只有一個參數，返回從該參數指定位置到數組末尾的所有項;如果有兩個參數，返回起始位置和結束位置之間的項，但不包括結束位置的項。如果，參數中有負數，則用數組長度加上該數來確定相應的位置。

splice()的主要用法：

刪除，2個參數：要刪除的第一項和要刪除的項數；

插入，3個參數：起始位置、0（要刪除的項數）和要插入的項；

替換，3個參數：起始位置、要刪除的項數和要插入的任意數量的項；

該方法始終都會返回一個數組。舉個例子：

刪除：

var cars = ["寶馬","奔馳","沃爾沃"];
var deleteCar = cars.splice(1, 2);
console.log(deleteCar); //["奔馳", "沃爾沃"]

插入：

var cars = ["寶馬","奔馳","沃爾沃"];
var addCar = cars.splice(1, 0, "特斯拉","保時捷");
console.log(cars); //["寶馬", "特斯拉", "保時捷", "奔馳", "沃爾沃"]

替換：

var cars = ["寶馬","奔馳","沃爾沃"];
var replaceCar = cars.splice(1, 1, "保時捷");
console.log(replaceCar); //["奔馳"] 刪除了奔馳
console.log(cars); //["寶馬", "保時捷", "沃爾沃"] 用保時捷替換了奔馳

indexOf()方法和lastIndexOf()方法。一個是從數組的開頭（位置0）開始向后查找；另一個則是從數組的末尾開始向前查找。有兩個參數：要查找的項和表示查找起點的位置索引。在比較第一個參數與數組中的每一項時，會使用全等操作符。如：

var numbers = [1,2,3,4,5,3];
document.write(numbers.indexOf(4)); //3
document.write(numbers.indexOf(4,5)); //-1 從第5索引開始查找，找不到就返回-1

document.write(numbers.lastIndexOf(3)); //5
document.write(numbers.lastIndexOf(3,0)); //-1 從第0索引開始反向查找，找不到就返回-1

document.write(numbers.indexOf(3)); //2 這里有兩個3 但是當搜索到第一個時就會停止搜索

Mark！！！！！！

Mark！！！！！！

Mark！！！！！！

var oliver = {name:"oliver"};
var person = [{name:"oliver"}];

var people = [oliver];

document.write(person.indexOf({name:"oliver"})); //-1
document.write(person.indexOf(oliver)); //-1

document.write(people.indexOf({name:"oliver"})); //-1
document.write(people.indexOf(oliver)); //0 必須變量搜索變量

有5 個迭代方法，每個方法接收兩個參數：要在每一項上運行的函數和作用域對象（可選）；傳入這些方法中的函數則接收三個參數：數組項的值（item）、索引位置（index）、數組對象本身（array）。

every()：每一項運行該函數，如果都返回true，則返回true；（返回Noolean）（主要是驗證）

some()：每一項運行該函數，如果其中任一項返回true，則返回true；（返回Boolean）（主要是驗證）

filter()：每一項運行該函數，對于那些返回true的項，組成一個數組；（返回Array）（主要是驗證）

map()：每一項運行該函數，返回的結果組成一個數組；（返回Array）(對數組操作)

forEach()：每一項運行該函數，沒有返回值；（不返回）（對數組操作）(本質上與for 語句類似)

下面是例子：

every()：

var numbers = [1,3,2,5,4];
var result = numbers.every(function(item, index, array){
    return item > 0;
});
document.write(result); //都大于零，返回true

some()：

var numbers = [1,5,4,32];
var result = numbers.some(function(item, index, Array){
    return item > 31;
});
document.write(result); //true 數組中至少有一項滿足條件，返回true

filter()：

var array = [123,"Oliver","Troy",true];
var newArray = array.filter(function(item, index, array){
    return typeof item == "string";
});
console.log(newArray); //["Oliver", "Troy"] 把滿足條件的部分返回一個數組

map()：

var array = [123,"Oliver","Troy",true];
var newArray = array.map(function(item, index, array){
    return item += " (Oliver)";
});
console.log(newArray); //["123 (Oliver)", "Oliver (Oliver)", "Troy (Oliver)", "true (Oliver)"]

forEach()：

    var array = [123,"Oliver","Troy",true];
array.forEach(function(item, index, array){
    if (typeof item == "number"){
        document.write((item + 877) + "
");
    }else if (typeof item == "string"){
        document.write("This is a string: " + item + "
")
    }else{
        document.write(item + "ly")
    }
});

/*
1000
This is a string: Oliver
This is a string: Troy
truely
*/

兩個方法：reduce()和reduceRight()，這兩個方法都會迭代數組的所有項，然后構建一個最終返回的值。前者是從數組的第一項開始，后者是從數組的最后一項開始。他們有兩個參數：一個在每一項上調用的函數和最為歸并基礎的初始值。函數則包括4 個參數：前一個值（prev）、當前值（cur）、項的索引（index）、數組本身（array）。如：

var numbers = [1,3,2,4,5,7,6];
var result = numbers.reduce(function(prev, cur, index, array){
    return prev + cur;
});
console.log(result); //28

又如：

var array = [321,false,"Oliver",21];
var newArray = array.reduce(function(prev, cur, index, array){
    return prev + cur;
});
console.log(newArray); //321Oliver21
newArray = array.reduceRight(function(prev, cur, index, array){
    return prev + cur;
});
console.log(newArray); //21Oliverfalse321 這里出現了false 是因為+ 操作符的原因
console.log(21+"oliver"+false+321); //false 被轉換成字符串
console.log(321+false+"oliver"+21); //false 被轉換成數值
console.log(321+(false+"oliver"+21)); //false 被轉換字符串，括號的原因

（今天內容還真是有點多，看007去了，回來再復習）