陣列是一組按序排列的值;相對地,物件的屬性名稱是無序的。從本質上說,陣列用數字作為查找鍵,而物件則由使用者自訂屬性名。JavaScript 沒有真正的關聯陣列,但物件可以勝任類似的工作。
嚴格講來,Array() 只是一種特殊的 Object()——Array 的實例基本上就是多了幾項額外能力的 Object 實例。陣列可以裝任何型別的值,隨時更新或刪除,而且大小會自動調整。除了物件之外,陣列大概是 JavaScript 裡最常被使用的型別,同時它與多數語言的陣列也有相當大的差異。
var empty = []; // 沒有元素的陣列 var primes = [2, 3, 5, 7, 11]; // 五個數值
JavaScript 陣列的每一項都可以是任何型別的資料:
var misc = [1.1, true, "a"]; // 三種不同型別
字面量中的值也不必是常量,可以是任意表達式:
var base = 1024; var table = [base, base + 1, base + 2, base + 3];
還可以包含物件字面量或其他陣列字面量;若元素本身又是陣列,就形成多維陣列:
var b = [ [1, {x: 1, y: 2}], [2, {x: 3, y: 4}] ];
var a = [[1, 2], [3, 4]];
注意:使用字面量語法時不會呼叫 Array 建構函式。
有三種呼叫方式。不帶參數,得到空陣列,等同 []:
var a = new Array();
帶一個數值參數,該值用來指定陣列長度:
var a = new Array(10); console.log(a); // [] console.log(a[0], a.length); // undefined 10
但若傳入的是其他型別,就會建立一個只含該值的單元素陣列:
var a = new Array('10');
console.log(a); // ['10']
console.log(a[0], a.length); // 10 1
帶多個參數時,參數即為陣列的具體元素:
var a = new Array(1, 2, 3); console.log(a); // [1, 2, 3] console.log(a[0], a[1], a[2]); // 1 2 3
使用 Array() 時可以省略 new:
var a1 = Array(); var a2 = Array(10); var a3 = Array(1, 2, 3);
陣列是特殊的物件:
typeof [1, 2, 3] // "object"
它的特殊性在於鍵名是一組按序排列的整數(0、1、2……)。由於鍵名固定,陣列不必逐一指定;而物件的每個成員都必須自訂鍵名:
var arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // ["0", "1", "2"]
var obj = { name1: 'a', name2: 'b', name3: 'c' };
用方括號存取陣列元素,和用方括號存取物件屬性其實是同一件事:
JavaScript 規定物件的鍵名一律是字串,所以陣列鍵名實際上也是字串。之所以能用數字讀取,是因為非字串鍵名會先被轉成字串再當屬性名使用:
o = {}; // 普通物件
o[1] = "one"; // 用整數索引它,實際上是 "1"
var arr = ['a', 'b', 'c'];
arr['0'] // 'a'
arr[0] // 'a'
但務必區分「陣列索引」與「物件屬性名」:所有索引都是屬性名,但只有落在 0 到 2³²−2(即 4294967294)之間的整數屬性名才算索引。
var a = []; a['1000'] = 'abc'; // 索引 a[1000] // 'abc' a[1.00] = 6; // 1.00 會被轉成 "1",仍是索引 a[1] // 6
另外,單獨的數字不能作為識別符,所以陣列成員只能用方括號取值:
var arr = [1, 2, 3]; arr[0]; // 1 arr.0; // SyntaxError
負數或非整數也能用來取值,但由於不在索引範圍內,它們只是普通的屬性名,最明顯的特徵是不會改變陣列長度:
var a = [1, 2, 3]; a[-1.23] = true; // 屬性名 console.log(a.length); // 3 a[10] = 5; // 索引 console.log(a.length); // 11 a['abc'] = 'testing'; // 屬性名 console.log(a.length); // 11
稀疏陣列指的是索引從 0 開始卻不連續的陣列。
最直接的做法是用 delete:
var a = [1, 2, 3, 4, 5]; delete a[1]; console.log(a[1]); // undefined console.log(1 in a); // false
也可以在字面量中省略元素值:
var a = [1, , 3, 4, 5]; console.log(a[1]); // undefined console.log(1 in a); // false
「省略值」與「值為 undefined」並不相同:
var a = [1, , 3, 4, 5]; console.log(1 in a); // false var a = [1, undefined, 3, 4, 5]; console.log(1 in a); // true
結尾多一個逗號時各瀏覽器行為不一:標準瀏覽器會忽略,IE8 及更早版本則會補上一個 undefined:
// 標準瀏覽器輸出 [1, 2],IE8- 輸出 [1, 2, undefined] var a = [1, 2,]; console.log(a); // 標準瀏覽器輸出 2,IE8- 輸出 3 var a = [,,]; console.log(a.length);
夠稀疏的陣列,在實作上通常比稠密陣列更慢、記憶體佔用更高,查找元素的耗時也與一般物件屬性相當。
每個陣列都有一個 length 屬性,這是它與普通物件的主要區別。對稠密陣列而言,length 代表元素個數,其值恆比最大索引大 1:
[].length // => 0 ['a', 'b', 'c'].length // => 3,最大索引為 2
稀疏陣列同樣如此,此時 length 會大於實際元素個數:
[, , ,].length; // 3 (Array(10)).length; // 10 var a = [1, 2, 3]; console.log(a.length); // 3 delete a[1]; console.log(a.length); // 3
陣列最核心的特殊之處在於 length 可以動態調整:
一、為索引 i 賦值且 i ≥ 目前長度時,length 會被設為 i + 1:
var arr = ['a', 'b']; arr.length // 2 arr[2] = 'c'; arr.length // 3 arr[9] = 'd'; arr.length // 10 arr[1000] = 'e'; arr.length // 1001
二、把 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(5)
因此,清空陣列最有效的方式就是把 length 設為 0:
var arr = ['a', 'b', 'c']; arr.length = 0; arr // []
三、把 length 設為大於目前長度的值,實際上不會添加元素,只是在尾部開出一塊空洞:
var a = ['a']; a.length = 3; console.log(a[1]); // undefined console.log(1 in a); // false
若把 length 設為非法值(超出 0 到 2³²−2 的範圍),JavaScript 會拋錯:
[].length = -1; // RangeError: Invalid array length [].length = Math.pow(2, 32); // RangeError: Invalid array length [].length = 'abc'; // RangeError: Invalid array length
由於陣列本質上是物件,也可以替它掛一般屬性,但這不會影響 length:
var a = []; a['p'] = 'abc'; console.log(a.length); // 0 a[2.1] = 'abc'; console.log(a.length); // 0
最常見的是 for 迴圈:
var a = [1, 2, 3];
for (var i = 0; i < a.length; i++) {
console.log(a[i]);
}
while 迴圈也可以:
var a = [1, 2, 3];
var i = 0;
while (i < a.length) { console.log(a[i]); i++; }
var l = a.length;
while (l--) { console.log(a[l]); }
但若陣列是稀疏的,for 迴圈需要多一道判斷:
var a = [1, , , 2];
for (var i = 0; i < a.length; i++){
if (!(i in a)) continue; // 跳過不存在的元素
console.log(a[i]);
}
for/in 也能處理稀疏陣列,它只列舉實際存在的可列舉屬性名(含索引):
var a = [1, , , 2];
for (var i in a){ console.log(a[i]); }
但 for/in 會連繼承而來的可列舉屬性一起列出,例如有人往 Array.prototype 上掛的方法,所以在陣列上通常不建議使用它,除非加上額外過濾:
var a = [1, , , 2];
a.b = 'b';
for (var i in a){ console.log(a[i]); } // 1 2 'b'
// 只保留非負整數索引
var a = [1, , , 2];
a.b = 'b';
for (var i in a){
if (String(Math.floor(Math.abs(Number(i)))) !== i) continue;
console.log(a[i]); // 1 2
}
規範允許 for/in 以任意順序遍歷屬性。陣列元素的遍歷實作通常是升序,但並不保證。特別是當陣列同時帶有物件屬性與索引時,回傳順序很可能依建立順序而非數值大小。若演算法依賴遍歷順序,請改用一般的 for 迴圈。
擁有 length 屬性與對應非負整數屬性的物件,稱為類陣列:
var a = {};
var i = 0;
while (i < 10){ a[i] = i * i; i++; }
a.length = i;
var total = 0;
for (var j = 0; j < a.length; j++){ total += a[j]; }
最常見的三種類陣列是:
arguments 物件
function args() { return arguments }
var arrayLike = args('a', 'b');
arrayLike[0] // 'a'
arrayLike.length // 2
arrayLike instanceof Array // false
DOM 方法回傳的集合,例如 getElementsByTagName():
var elts = document.getElementsByTagName('h3');
elts.length // 3
elts instanceof Array // false
字串
'abc'[1] // 'b' 'abc'.length // 3 'abc' instanceof Array // false
要注意字串是不可變值,把它當陣列看待時是唯讀的。push()、sort()、reverse()、splice() 這些會修改陣列的方法用在字串上會失效甚至報錯:
var str = 'abc';
Array.prototype.forEach.call(str, function(chr) {
console.log(chr); // a b c
});
Array.prototype.splice.call(str, 1);
// TypeError: Cannot delete property '2' of [object String]
若要把類陣列轉成真陣列,用 slice:
var arr = Array.prototype.slice.call(arrayLike);
JavaScript 的陣列方法是刻意設計成通用的,因此不但能用在真正的陣列上,也能正確作用於類陣列。ES5 中全部陣列方法都是通用的;ES3 中除 toString() 與 toLocaleString() 之外也全部通用:
var a = { '0': 'a', '1': 'b', '2': 'c', length: 3 };
Array.prototype.join.call(a, '+'); // 'a+b+c'
Array.prototype.slice.call(a, 0); // ['a', 'b', 'c']
Array.prototype.map.call(a, function(x){ return x.toUpperCase(); });
// ['A', 'B', 'C']