ECMAScript的數組，每一項可以保存任何類型的數據，數組的大小可以動態調整。
創建方法
構造函數
1. var 變量名 = new Array(數組長度（可爲空）); 2. var 變量名 = new Array(項0，項1………...);數組字面量
var 變量名= [項0，項1………（可爲空）];
檢測數組
1. 變量名 instanceof Array; （instanceof假定只有一個全局執行環境，當網頁 包含多個框架時不適用）
2. Array.isArray(變量名);
（不管arr是在哪個全局執行環境中創建的）
轉換方法
1. arr.toString() //返回字符串，以逗號分割每一項
2. arr.toLocaleString() //返回字符串，以逗號分割每一項
3. arr.valueof() //返回數組，以逗號分割每一項
4. arr.join(“分隔符”) 返回字符串，以自定義的分隔符分割每一項，若不傳入分隔符，默認爲逗號
若數組某項爲null 或 undefined，在以上方法中， 該項顯示爲空字符串
棧方法 LIFO
1. 正方向模擬棧：
▪ 在數組末尾添加新項： arr.push(新項j，新項k…….)； // 返回數組新的長度
▪ 在數組末尾移除項： arr.pop(); //返回移除的項
2. 反方向模擬棧：
▪ 在數組頭部添加新項： arr.unshift(新項j，新項k…….)； // 返回數組新的長度
▪ 在數組頭部移除項： arr.shift(); //返回移除的項
隊列方法 FIFO
1. 正方向模仿隊列：
▪ 在數組末尾添加新項： arr.push(新項j，新項k…….)； // 返回數組新的長度
▪ 在數組頭部移除項： arr.shift(); //返回移除的項
2. 反方向模擬隊列：
▪ 在數組頭部添加新項： arr.unshift(新項j，新項k…….)； // 返回數組新的長度
▪ 在數組末尾移除項： arr.pop(); //返回移除的項
重排序方法
1. arr.reverse() //反轉數組項的順序
2. arr.sort() //默認升序排列數組項，但是比較的是字符串，所以會出現 (1，10，2)的結果。
因此，最好用sort（function），接受一個比較函數
//數值類型or 其valueOf方法返回數值類型的對象類型
function compare(value1,value2){
return value1-value2; //升序
或者
return value2-value1; //降序
}
var arrays = ["80", "9", "700", 40, 1, 5, 200];
arrays.sort(compare);
console.log(arrays); //[ 1, 5, '9', 40, '80', 200, '700' ]升序
//[ '700', 200, '80', 40, '9', 5, 1 ]降序//自實現sort方法原理
var ascsort = function(value1,value2){
return value1 - value2;
}
function descsort(value1,value2){
return value2-value1;
}
Array.prototype.mysort = function(fn){
fn = fn || function(x,y){return x-y;}; //默認升序
for(var i =0;i<this.length;i++){
for(var j=i;j<this.length;j++){
if(fn(arr[i],arr[j])>0){
arr[i] ^= arr[j];
arr[j] ^= arr[i];
arr[i] ^= arr[j];
}
}
}
}
var arr=new Array(1,10,9,22,100,31);
arr.mysort();
console.log(arr);//[ 1, 9, 10, 22, 31, 100 ]
arr.mysort(ascsort);
console.log(arr);//[ 1, 9, 10, 22, 31, 100 ]
arr.mysort(descsort);
console.log(arr);//[ 100, 31, 22, 10, 9, 1 ]//根據對象的屬性來排序
function createComparisonFunction(propertyName){
return function(object1,object2){
var value1 = object1[propertyName];
var value2 = object2[propertyName];
//忽略大小寫
if(propertyName == "name"){
value1 = value1.toLowerCase();
value2 = value2.toLowerCase();
}
return +(value1 > value2)||-(value1 < value2);
};
}
var data = [{name:"Zachary",age:28},{name:"cicholas",age:30},{name:"karine",age:40},{name:"Aicholas",age:25},{name:"karine",age:40}];
data.sort(createComparisonFunction("name"));
console.log(data);
//[ { name: 'Aicholas', age: 25 },
// { name: 'cicholas', age: 30 },
// { name: 'karine', age: 40 },
// { name: 'karine', age: 40 },
// { name: 'Zachary', age: 28 } ]
data.sort(createComparisonFunction("age"));
console.log(data);
//[ { name: 'Aicholas', age: 25 },
// { name: 'Zachary', age: 28 },
// { name: 'cicholas', age: 30 },
// { name: 'karine', age: 40 },
// { name: 'karine', age: 40 } ]分析一下return語句“return +(value1 > value2)||-(value1 < value2);”：
▪ value1>value2 -> +true||-false -> 1||-0 -> 1
▪ value1<value2 -> +false||-true -> 0|| -1 -> -1
▪ value1=value2 -> +false||-false -> 0||-0 -> -0
操作方法
1. arr.concat(參數（可以是新項or數組）) 複製數組arr，在副本數組末尾添加參數，不改變原數組。
*與arr.push（參數）的區別：
▪ push方法直接改變原數組，push方法如果接受的參數爲數組，會把該參數視爲一個項。
▪ concat方法不改變原數組，concat方法如果接受的參數爲數組，會把該參數的每個項視爲單獨的項。
2. arr.slice(起始位置，結束位置（可不寫）) //返回（arr[起始位置]到arr[結束位置-1]）的數組，不改變原數組
3. arr.splice(起始位置，要刪除的項數，插入/替換的項（可不寫）) //返回包含刪除項的數組，改變原數組
▪ 刪除 arr.splice(2,5); // 返回空數組，原arr變成從arr[2]到arr[4]
▪ 插入 arr.splice(1,0,"red","green"); //返回空數組，red、green從原arr的arr[1]插入
▪ 替換 arr.splice(1,3,"red","green"); //返回包含arr[1],arr[2],arr[3]的數組，
red、green從原arr的arr[1]插入
arr[1],arr[2],arr[3]的數組，red、green從原arr的arr[1]插入
var arr1=new Array(0,1,2);
var arr2=[4,5,6];
var arr3=arr2.concat(arr1);
console.log(arr3); //[ 4, 5, 6, 0, 1, 2 ]
arr3[1]=6;
arr3[3]=1;
console.log(arr3); //[ 4, 6, 6, 1, 1, 2 ]
console.log(arr1); //[ 0, 1, 2 ]不會改變原數組
console.log(arr2); //[ 4, 5, 6 ]不會改變原數組
---------------------------------------------------
var arr5={name:"lala"};
var arr6=[4,5,6];
var arr7=arr6.concat(arr5);//拷貝的是對象引用
console.log(arr7); //[ 4, 5, 6, { name: 'lala' } ]
arr7[3]["name"]="xixi";
console.log(arr7); //[ 4, 5, 6, { name: 'xixi' } ]
console.log(arr6); //[ 4, 5, 6] 不會改變原數組
console.log(arr5["name"]); //xixi,作爲參數的arr5原數組被改變位置方法
1. arr.indexOf(起始位置（可不寫），待查找元素) //在數組頭部往後查找，返回元素在數組的位置，找不到返回-1
2. arr.lastIndexOf(結束位置（可不寫），待查找元素) //在數組末尾往前查找，返回元素在數組的位置，找不到返回-1
迭代方法（不改變原數組）
作爲參數的函數會接收3個參數：item,index,array
1. arr.every(函數) //如果函數對數組每一項都返回true，則返回true
2. arr.some(函數) //如果函數對數組某一項返回true，則返回true
3. arr.filter(函數) //返回一個由函數返回true的項組成的數組
4. arr.map(函數) //返回每一項調用函數的結果組成的數組
5. arr.forEach(函數) //沒有返回值，每一項執行函數。
歸併方法
作爲參數的函數會接收4個參數：prev, cur, index, array
1. arr.reduce(函數) 從數組第一項開始，遍歷到最後
2. arr.reduceRight(函數) 從數組最後一項開始，遍歷到第一項。