JavaScript-陣列

陣列是值的有序集合，
每個值叫做一個元素，而每個元素在陣列中有一個位置，以數字表示，稱為索引，
JavaScript陣列是無型別的：陣列元素可以是任意型別，并且同一個陣列中的不同元素也可能有不同的型別，

創建陣列

var a = [];
//沒有元素的陣列
var b = [2,3,4,5,6];
//有5個數值的陣列
var c = [1.1,true,"a",];
//3個不同型別的元素的陣列

值不一定要是常量；它們可以是任意的運算式：

var a = 1;
var b = [a,a+1,a+2,a+3];

如果省略陣列直接量中的某個值，省略的元素將被賦予undefined值：

var a = [1,,3];
//中間元素為undefined
var b = [,,];
//陣列直接量的語法允許有可選的結尾的逗號，故[,,]只有兩個元素而非三個，
//2個元素為undefined

Array（）創建陣列

var a = new Array();
//空陣列
var b = new Array(10);
//創建一個長度為10的陣列
var c = new Array(1,2,3,4,5,"a");
//創建一個元素為括號中元素的陣列

陣列元素的讀和寫

var a = ["abc"];
var b = a[0];	//讀第0個元素
陣列索引從0開始
a[1] = 3 //寫第一個元素
i = 2;
a[i] = 3; //寫第2個元素
a[i+1] = "qqq"; //寫第3個元素

注意，可以使用負數或非整數來索引陣列，這種情況下，數值轉換為字串，字串作為屬性名來用，既然名字不是非負整數，它就只能當做常規的物件屬性，而非陣列的索引，同樣，如果湊巧使用了是非負整數的字串，它就當做陣列索引，而非物件屬性，當使用的一個浮點數和一個整數相等時情況也是一樣的：

a[-1.23] = true;
//創建一個名為"-1.23"的屬性
a["1000"] = 0;
//寫陣列的第1000個元素
a[1.00] 
//和a[1]相等

事實上陣列索引僅僅是物件屬性名的一種特殊型別，這意味著JavaScript陣列沒有“越界”錯誤的概念，當試圖查詢任何物件中不存在的屬性時，不會報錯，只會得到undefined值，類似于物件，對于物件同樣存在這種情況，

稀疏陣列

稀疏陣列就是包含從0開始的不連續索引的陣列，通常，陣列的length屬性值代表陣列中元素的個數，如果陣列是稀疏的，length屬性值大于元素的個數，

a = new Array(5);
//陣列沒有元素，但是a.length是5
a = []; 
//創建一個空陣列，length = 0
a[1000] = 0；
//賦值添加一個元素，但是設定length為1001

注意，當在陣列直接量中省略值時不會創建稀疏陣列，省略的元素在陣列中是存在的，其值為undefined，

var a1 = [,,,]
//陣列是[undefined,undefined,undefined]
var a2 = new Array(3);
//該陣列沒有元素
0 in a1
//true a1在索引0處有一個元素
0 in a1
//false a2在索引0處有一個元素

陣列長度

length屬性值代表陣列中元素的個數，

[].length //length為0 陣列沒有元素
['a','b','c'].length // length為3

設定length屬性為一個小于當前長度的非負整數n時，當前陣列中那些索引值大于或等于n的元素將從中洗掉：

a = [1,2,3,4,5];
a.length = 3; //現在a為[1,2,3]
a.length = 0; //洗掉所有的元素，a為[]
a.length = 5; //長度為5，但是沒有元素 與new Array 相同

陣列元素的添加和洗掉

a = [] //空陣列
a[0] = "a" //為新索引賦值

使用push（）方法在陣列末尾增加一個或多個元素

a = [];
a.push("a") //a=["a"]
a.push("b","c") //a=["a","b","c"]

使用delete運算子來洗掉陣列元素

a = [1,2,3];
delete a[1];
1 in a //false
a.length //3 delete操作并不影響陣列長度

陣列遍歷

a=[1,2,3,4,5,6];
b=[];
for (var i=0,len=a.length; i<len; i++)
{
	b[i] = a[i];
}

多維陣列

JavaScript不支持真正的多維陣列，但可以用陣列的陣列來近似，訪問陣列的陣列中的元素，只要簡單地使用兩次 [ ] 運算子即可，

例如，假設變數matrix是一個陣列的陣列，它的基本元素是數值，那么matrix[x]的每個元素是包含一個數值陣列，訪問陣列中特定數值的代碼為matrix[x][y]，

陣列方法

join（）

將陣列中所有元素都轉化為字串并連接在一起，回傳最后生成的字串，

var a = [1,2,3];
a.join(); //"1,2,3"
a.join(" "); //"1 2 3"
a.join(""); //"123"

reverse（）

將陣列中的元素顛倒順序，回傳逆序的陣列，

var a = [1,2,3];
a.reverse().join() //"3,2,1"

sort（）

將陣列中的元素排序并回傳排序后的陣列，

var a = new Array("b","c","a");
a.sort(); //a=["a","b","c"]

concat（）

創建并回傳一個新陣列，它的元素包括呼叫concat（）的原始陣列的元素和concat（）的每個引數，

var a = [1,2,3];
a.concat(4,5) // 回傳[1,2,3,4,5]
a.concat([4,5]) // 回傳[1,2,3,4,5]
a.concat([4,5],[6,7]) // 回傳[1,2,3,4,5,6,7]
a.concat(4,[5,[6,7]) // 回傳[1,2,3,4,5,[6,7]]

slice（）

回傳指定陣列的一個片段或子陣列，它的兩個引數分別指定了片段的開始和結束的位置，回傳的陣列包含第一個引數指定的位置和所有到但不含第二個引數指定的位置之間的所有陣列元素，

var a = [1,2,3,4,5];
a.slice(0,3); //回傳[1,2,3]
a.slice(3);   //回傳[4,5]
//如果只指定一個引數，回傳的陣列將包含從開始位置到陣列結尾的所有元素，
a.slice(1,-1); //回傳[2,3,4]
//引數-1指定了最后一個元素

splice（）

在陣列中插入或洗掉元素的通用方法，不同于slice（）和concat（），splice（）會修改呼叫的陣列，
splice（）的第一個引數指定了插入和（或）洗掉的起始位置，第二個引數指定了應該從陣列中洗掉的元素的個數，

var a = [1,2,3,4,5,6,7,8];
s.splice(4); //回傳[5,6,7,8]; a是[1,2,3,4]
//如果省略第二個引數，從起始點開始到陣列結尾的所有元素都將被洗掉，
s.splice(1,2); //回傳[2,3]; a是[1,4]
s.splice(1,1); //回傳[4]; a是[1]

splice（）的前兩個引數指定了需要洗掉的陣列元素，緊隨其后的任意個數的引數指定了需要插入到陣列中的元素，從第一個引數指定的位置開始插入，

var a = [1,2,3,4,5];
s.splice(1,0,'a','b');
//回傳[]; a是[1,'a','b',2,3,4,5]

push（）和pop（）

push（）方法在陣列的尾部添加一個或多個元素，并回傳陣列新的長度，
pop（）方法則相反：它洗掉陣列的最后一個元素，減小陣列長度并回傳它洗掉的值，

兩個方法都修改并替換原始陣列而非生成一個修改版的新陣列，

var a = []; // a: []
a.push(1,2); // a:[1,2] 回傳2
a.pop(); //a:[1] 回傳2

unshift（）和shift（）

unshift（）在陣列的頭部添加一個或多個元素，并將已存在的元素移動到更高索引的位置來獲得足夠的空間，最后回傳陣列新的長度，
shift（）洗掉陣列的第一個元素并將其回傳，然后把所有隨后的元素下移一個位置來填補陣列頭部的空缺，

var a = [];
a.inshift(1); //a:[1] 回傳1
a.inshift(2); //a:[2,1] 回傳2
a.shift(); //a:[1] 回傳 2

toString（）

陣列和其他JavaScript物件一樣擁有toString（）方法，針對陣列，該方法將其每個元素轉化為字串，并且輸出用逗號分隔的字串串列，

[1,2,3].toString() //生成'1,2,3'
[1,"b",3].toString() //生成'1,b,3'
[1,[2,3]].toString() //生成'1,2,3'

ECMAScript5中的陣列方法

forEach（）

forEach（）方法從頭至尾遍歷陣列，為每個元素呼叫指定的函式，

var data = [1,2,3,4,5];
var sum = 0;
data.forEach(
function (value){
	sum += value;
}
);
//sum: 15

map（）

map（）方法將呼叫的陣列的每個元素傳遞給指定的函式，并回傳一個陣列，它包含該函式的回傳值，

a = [1,2,3];
b = a.map(function (x) {return x*x;});
//b: [1,4,9]

filter（）

fliter（）方法回傳的陣列元素是呼叫的陣列的一個子集，傳遞的函式是用來邏輯判定的：該函式回傳true或false，

a = [5,4,3,2,1];
s = a.filter(
function(x){
	return x<3
});
// s:[2,3]

every（）和some（）

every（）和some（）方法是陣列的邏輯判定：它們對陣列元素應用指定的函式進行判定，回傳true或false，

every（）方法就像數學中的“針對所有”的量詞：當且僅當針對陣列中的所有元素呼叫判定函式都回傳true，它才回傳true：

a = [1,2,3,4,5];
a.every(function(x){
	return x<10;
}) // true
a.every(function(x){
	return x>10;
}) // false

some（）方法就像數學中的“存在”的量詞：當陣列中至少有一個元素呼叫判定函式回傳true，它就回傳true；并且當且僅當數值中的所有元素呼叫判定函式都回傳false，它才回傳false：

a = [1,2,3,4,5];
a.some(function(x){
	return x<2;
}) //true
a.some(function(x){
	return x>5;
}) //false

indexOf（）和lastIndexOf（）

indexOf（）和lastIndexOf（）搜索整個陣列中具有給定值的元素，回傳找到的第一個元素的索引或者如果沒有找到就回傳-1，

indexOf（）從頭至尾搜索，而lastIndexOf（）則反向搜索，

a = [0,1,2,1,0];
a.indexOf(1) //1: a[1]是1
a.lastIndexOf(1) // 3: a[3]是1
a.indexOf(3) //-1 沒有值為3的元素

作為陣列的字串

除了用charAt（）方法來訪問單個的字符以外，還可以使用方括號：

var a = test;
s.charAt(0) // "t"
s[1] // "e"

參考資料：《JavaScript權威指南》