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' ]

如果元素需要多个维度，则必须嵌套数组。 创建此类嵌套数组时，最里面的数组可以根据需要增长。但是，如果要直接访问元素，则至少需要创建外部数组。在以下示例中，我创建了一个用于井字游戏的 3x3 矩阵。该矩阵完全填充了数据（而不是让行根据需要增长）：

// 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。规范中明确排除了上限（如前所述）。它保留用于最大长度。要查看此定义的工作原理，让我们使用 通过按位运算符实现 32 位整数 中的函数 ToUint32()。

首先，不包含数字的字符串始终转换为 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，因此两者非常相似。

具有空洞的数组称为稀疏数组。 没有空洞的数组称为密集数组。密集数组是连续的，并且在每个索引处都有一个元素，从零开始，到 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 进行迭代会跳过 空洞，但不会跳过 undefined 元素：

> 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 循环很难做到的事情）做出不同的反应。

转换 方法接受一个输入数组并生成一个输出数组，而回调函数控制输出的生成方式。回调函数具有与检查相同的签名：

function callback(element, index, array)

有两种转换方法：

对于归约，回调函数 具有不同的签名：

function callback(previousValue, currentElement, currentIndex, array)

参数 previousValue 是回调函数先前返回的值。当首次调用回调函数时，有两种可能性（描述适用于 Array.prototype.reduce()；括号中提到了与 reduceRight() 的区别）

有两种归约方法

查看 reduce 方法的另一种方法是，它通过一系列二元运算符 op2 的应用来实现 n 元运算符 OP

OP1≤i≤n x_i

(...(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'