ECMAScript 標準將陣列指定為從索引到值的映射 (字典)。換句話說，陣列可能不是連續的，而且可能會有空洞。例如：

> var arr = [];
> arr[0] = 'a';
'a'
> arr[2] = 'b';
'b'
> arr
[ 'a', , 'b' ]

前述陣列有一個空洞：索引 1 沒有元素。 陣列中的空洞 會更詳細地說明空洞。

請注意，大多數 JavaScript 引擎會在內部最佳化沒有空洞的陣列，並將它們連續儲存。

陣列仍然是物件，而且可以有物件屬性。這些屬性不被視為實際陣列的一部分；換句話說，它們不被視為陣列元素：

> var arr = [ 'a', 'b' ];
> arr.foo = 123;
> arr
[ 'a', 'b' ]
> arr.foo
123

有兩種使用建構函式 Array 的方法：您可以建立具有指定長度的空陣列，或建立元素為指定值的陣列。對於此建構函式，new 是可選的：將其呼叫為一般函式 (不使用 new) 的效果與將其呼叫為建構函式相同。

> var arr = new Array(2);
> arr.length
2
> arr  // two holes plus trailing comma (ignored!)
[ , ,]

// The same as ['a', 'b', 'c']:
var arr1 = new Array('a', 'b', 'c');

> new Array(2)  // alas, not [ 2 ]
[ , ,]

> new Array(5.7)  // alas, not [ 5.7 ]
RangeError: Invalid array length

> new Array('abc')  // ok
[ 'abc' ]

如果您需要多維的元素，您必須巢狀陣列。當您建立此類巢狀陣列時，最內層的陣列可以視需要而擴充。但是，如果您想要直接存取元素，您至少需要建立外層陣列。在以下範例中，我建立一個三乘三的井字遊戲矩陣。矩陣完全填滿資料（與讓列視需要而擴充相反）：

// Create the Tic-tac-toe board
var rows = [];
for (var rowCount=0; rowCount < 3; rowCount++) {
    rows[rowCount] = [];
    for (var colCount=0; colCount < 3; colCount++) {
        rows[rowCount][colCount] = '.';
    }
}

// Set an X in the upper right corner
rows[0][2] = 'X';  // [row][column]

// Print the board
rows.forEach(function (row) {
    console.log(row.join(' '));
});

以下是輸出

. . X
. . .
. . .

我希望範例示範一般情況。很明顯地，如果矩陣很小而且具有固定維度，您可以透過陣列文字設定它

var rows = [ ['.','.','.'], ['.','.','.'], ['.','.','.'] ];

in 運算子 會偵測物件是否具有具有特定金鑰的屬性。但是，它也可以用來判斷陣列中是否存在特定元素索引。例如：

> var arr = [ 'a', , 'b' ];
> 0 in arr
true
> 1 in arr
false
> 10 in arr
false

除了刪除屬性之外， delete 運算子 也會刪除陣列元素。刪除元素會產生空洞（ length 屬性不會更新）：

> var arr = [ 'a', 'b' ];
> arr.length
2
> delete arr[1]  // does not update length
true
> arr
[ 'a',  ]
> arr.length
2

您也可以透過減少陣列長度來刪除尾端的陣列元素（有關詳細資料，請參閱 length）。若要移除元素而不產生空洞（也就是後續元素的索引會遞減），請使用 Array.prototype.splice()（請參閱 新增和移除元素（破壞性））。在此範例中，我們在索引 1 移除兩個元素

> var arr = ['a', 'b', 'c', 'd'];
> arr.splice(1, 2) // returns what has been removed
[ 'b', 'c' ]
> arr
[ 'a', 'd' ]

陣列索引並非表面上所見。到目前為止，我假裝陣列 索引是數字。而這是 JavaScript 引擎在內部實作陣列的方式。然而，ECMAScript 規範以不同的方式看待索引。改寫 第 15.4 節

換句話說，在規範的世界中，括號中的所有值都會轉換為字串並解釋為屬性金鑰，甚至是數字。下列互動展示了這一點

> var arr = ['a', 'b'];
> arr['0']
'a'
> arr[0]
'a'

要成為陣列索引，屬性金鑰 P（字串！）必須等於下列運算的結果

這表示陣列索引必須是 32 位元範圍 0 ≤ i < 2³²−1 中的字串化整數 i。規範中明確排除了上限（如前所述）。它保留給最大長度。讓我們使用 函式 ToUint32() 從 透過位元運算子取得 32 位元整數 來了解此定義如何運作。

首先，不包含數字的字串總是轉換為 0，字串化後，不等於字串

> ToUint32('xyz')
0
> ToUint32('?@#!')
0

其次，超出範圍的字串化整數也會轉換為完全不同的整數，字串化後，不等於字串

> ToUint32('-1')
4294967295
> Math.pow(2, 32)
4294967296
> ToUint32('4294967296')
0

第三，字串化的非整數數字會轉換為整數，再次地，不同

> ToUint32('1.371')
1

請注意，規範也強制執行陣列索引沒有指數

> ToUint32('1e3')
1000

且沒有前導零

> var arr = ['a', 'b'];
> arr['0']  // array index
'a'
> arr['00'] // normal property
undefined

手動增加陣列長度對陣列的影響非常小；它只會建立空洞：

> var arr = [ 'a', 'b' ];
> arr.length = 3;
> arr  // one hole at the end
[ 'a', 'b', ,]

最後的結果在結尾有兩個逗號，因為尾隨逗號是可選的，因此總是會被忽略。

我們剛剛執行的動作沒有新增任何元素

> countElements(arr)
2

然而，length 屬性會作為指標，顯示插入新元素的位置。例如

> arr.push('c')
4
> arr
[ 'a', 'b', , 'c' ]

因此，透過 Array 建構函式設定陣列的初始長度，會建立一個完全空的陣列

> var arr = new Array(2);
> arr.length
2
> countElements(arr)
0

如果你減少陣列長度，所有在新長度及以上位置的元素都會被刪除：

> var arr = [ 'a', 'b', 'c' ];
> 1 in arr
true
> arr[1]
'b'

> arr.length = 1;
> arr
[ 'a' ]
> 1 in arr
false
> arr[1]
undefined

function clearArray(arr) {
    arr.length = 0;
}

> var arr = [ 'a', 'b', 'c' ];
> clearArray(arr)
> arr
[]

arr = [];

> var a1 = [1, 2, 3];
> var a2 = a1;
> a1.length = 0;

> a1
[]
> a2
[]

> var a1 = [1, 2, 3];
> var a2 = a1;
> a1 = [];

> a1
[]
> a2
[ 1, 2, 3 ]

陣列的最大長度為 2³²−1：

> var arr1 = new Array(Math.pow(2, 32));  // not ok
RangeError: Invalid array length

> var arr2 = new Array(Math.pow(2, 32)-1);  // ok
> arr2.push('x');
RangeError: Invalid array length

你可以透過指定陣列索引來建立空洞：

> var arr = [];
> arr[0] = 'a';
> arr[2] = 'c';
> 1 in arr  // hole at index 1
false

您也可以透過在陣列字面中省略值來建立洞

> var arr = ['a',,'c'];
> 1 in arr  // hole at index 1
false

> [ 'a', ].length
1
> [ 'a', ,].length
2

本節探討洞與元素中的 undefined 之間的差異。由於讀取洞會傳回 undefined，因此兩者非常相似。

具有洞的陣列稱為 稀疏。 沒有洞的陣列稱為 稠密。稠密陣列是連續的，且每個索引中都有元素，從 0 開始，以 length − 1 結束。讓我們比較以下兩個陣列，一個稀疏陣列和一個稠密陣列。兩者非常相似：

var sparse = [ , , 'c' ];
var dense  = [ undefined, undefined, 'c' ];

洞幾乎就像在同一個索引中具有元素 undefined。兩個陣列的長度相同

> sparse.length
3
> dense.length
3

但稀疏陣列在索引 0 處沒有元素

> 0 in sparse
false
> 0 in dense
true

透過 for 進行反覆運算對兩個陣列來說是 相同的：

> for (var i=0; i<sparse.length; i++) console.log(sparse[i]);
undefined
undefined
c
> for (var i=0; i<dense.length; i++) console.log(dense[i]);
undefined
undefined
c

透過 forEach 進行反覆運算會略過洞，但不會略過未定義的元素：

> sparse.forEach(function (x) { console.log(x) });
c
> dense.forEach(function (x) { console.log(x) });
undefined
undefined
c

涉及 陣列的一些運算會忽略洞，而另一些運算則會考慮洞。本節說明詳細資訊。

> ['a',, 'b'].forEach(function (x,i) { console.log(i+'.'+x) })
0.a
2.b

> ['a',, 'b'].every(function (x) { return typeof x === 'string' })
true

> ['a',, 'b'].map(function (x,i) { return i+'.'+x })
[ '0.a', , '2.b' ]

> ['a',, 'b'].filter(function (x) { return true })
[ 'a', 'b' ]

> ['a',, 'b'].join('-')
'a--b'
> [ 'a', undefined, 'b' ].join('-')
'a--b'

> ['a',, 'b'].sort()  // length of result is 3
[ 'a', 'b', ,  ]

> for (var key in ['a',, 'b']) { console.log(key) }
0
2

> function f() { return [].slice.call(arguments) }
> f.apply(null, [ , , ,])
[ undefined, undefined, undefined ]

> Array.apply(null, Array(3))
[ undefined, undefined, undefined ]

> Array.apply(null, [2])
[ , ,]

正如我們所見，filter() 會移除洞：

> ['a',, 'b'].filter(function (x) { return true })
[ 'a', 'b' ]

使用自訂函式將任意陣列中的洞轉換為 undefined

function convertHolesToUndefineds(arr) {
    var result = [];
    for (var i=0; i < arr.length; i++) {
        result[i] = arr[i];
    }
    return result;
}

使用函式

> convertHolesToUndefineds(['a',, 'b'])
[ 'a', undefined, 'b' ]

對於數字，您可以直接傳回 a-b，但這可能會導致數字溢位。為了防止這種情況發生，您需要更冗長的程式碼：

function compareCanonically(a, b) {
    if (a < b) {
        return -1;
    } else if (a > b) {
        return 1;
    } else {
        return 0;
    }
}

我不喜歡巢狀條件運算子。但在這種情況下，程式碼簡潔許多，我忍不住推薦它：

function compareCanonically(a, b) {
    return a < b ? -1 : (a > b ? 1 : 0);
}

使用函式

> [-1, -20, 7, 50].sort(compareCanonically)
[ -20, -1, 7, 50 ]

對於字串，您可以使用 String.prototype.localeCompare（請參閱比較字串）

> ['c', 'a', 'b'].sort(function (a,b) { return a.localeCompare(b) })
[ 'a', 'b', 'c' ]

參數 compareFunction 也可用於排序物件：

var arr = [
    { name: 'Tarzan' },
    { name: 'Cheeta' },
    { name: 'Jane' } ];

function compareNames(a,b) {
    return a.name.localeCompare(b.name);
}

使用 compareNames 作為比較函式，arr 會依據 name 進行排序

> arr.sort(compareNames)
[ { name: 'Cheeta' },
  { name: 'Jane' },
  { name: 'Tarzan' } ]

本節中描述的每種方法如下所示：

arr.examinationMethod(callback, thisValue?)

此類方法會採用下列參數

以下是簽章剛才描述的檢查方法：

forEach() 的一個潛在陷阱是，它不支援 break 或類似用於提早中止迴圈的語法。如果你需要這麼做，可以使用 some()

function breakAtEmptyString(strArr) {
    strArr.some(function (elem) {
        if (elem.length === 0) {
            return true; // break
        }
        console.log(elem);
        // implicit: return undefined (interpreted as false)
    });
}

some() 會在發生中斷時傳回 true，否則傳回 false。這能讓你根據反覆運算是否成功完成而做出不同的反應（這在使用 for 迴圈時會有點棘手）。

轉換 方法會取得輸入陣列並產生輸出陣列，而 callback 則控制輸出的產生方式。callback 的簽章與檢查相同：

function callback(element, index, array)

有兩種轉換方法：

對於簡化，callback 具有不同的簽章：

function callback(previousValue, currentElement, currentIndex, array)

參數 previousValue 是 callback 先前傳回的值。當 callback 第一次呼叫時，有兩種可能性（說明是針對 Array.prototype.reduce()；括號中提到與 reduceRight() 的差異）

有兩種簡化方法

檢視 reduce 方法的另一種方式是，它實作 n 元運算子 OP

OP1≤i≤n x_i

透過連續應用二元運算子 op2

(...(x₁ op2 x₂) op2 ...) op2 x_n

這正是前一個程式碼範例所做的：我們透過 JavaScript 的二元加法運算子實作陣列的 n 元加法運算子。

讓我們透過以下函式來檢視兩個反覆運算方向，作為範例

function printArgs(prev, cur, i) {
    console.log('prev:'+prev+', cur:'+cur+', i:'+i);
    return prev + cur;
}

正如預期，reduce() 從左到右反覆運算

> ['a', 'b', 'c'].reduce(printArgs)
prev:a, cur:b, i:1
prev:ab, cur:c, i:2
'abc'
> ['a', 'b', 'c'].reduce(printArgs, 'x')
prev:x, cur:a, i:0
prev:xa, cur:b, i:1
prev:xab, cur:c, i:2
'xabc'

而 reduceRight() 從右到左反覆運算

> ['a', 'b', 'c'].reduceRight(printArgs)
prev:c, cur:b, i:1
prev:cb, cur:a, i:0
'cba'
> ['a', 'b', 'c'].reduceRight(printArgs, 'x')
prev:x, cur:c, i:2
prev:xc, cur:b, i:1
prev:xcb, cur:a, i:0
'xcba'