JS 稀疏数组

稀疏数组是指 索引不连续，数组长度大于元素个数的数组，通俗地说就是 有空隙的数组。我们可以通过下面的方式生成稀疏数组：

// 构造函数声明一个没有元素的数组
var a = new Array(5);    // [empty × 5]

// 指定的索引值大于数组长度
var a = [];
a[5] = 4;                // [empty × 5, 4]

// 指定大于元素个数的数组长度
var a = [];
a.length = 5;            // [empty × 5]

// 数组直接量中省略值
var a = [0,,,,];         // [0, empty × 3]

// 删除数组元素
var a = [0, 1, 2, 3, 4];
delete a[4];             // [0, 1, 2, 3, empty]

可见，写代码时稍不注意，是很容易产生稀疏数组的。

empty vs undefined

稀疏数组在控制台中的表示：

var a = new Array(5);
console.log(a);    // [empty × 5]

这里表示数组 a 有5个空隙。 empty 并非 JS 的基础数据类型，那它到底是什么东西？我们试着访问数组元素：

a[0];    // undefined

难道 empty 和 undefined 是一个含义？其实不然，我们来看看这个数组：

var b = [undefined, undefined, undefined];
console.log(b);    // [undefined, undefined, undefined]
b[0];              // undefined

a.forEach(i => { console.log(i) });    // 无 log 输出
b.forEach(i => { console.log(i) });    // undefined undefined undefined

数组 a 和 数组 b 只有访问具体元素的时候输出一致，其他情况都是存在差异的。遍历数组 a 时，由于数组中没有任何元素，所以回调函数不执行不会有 log 输出；而遍历数组 b 时，数组其实填充着元素 undefined，所以会打印 log。

这里的数组 b 其实是一个 密集数组。

至于为什么访问稀疏数组的缺失元素时会返回 undefined，是因为 JS 引擎在发现元素缺失时会临时赋值 undefined，类似于 JS 变量的声明提升：

console.log(a);    // undefined
var a = 0;

转化为密集数组

// 稀疏数组
var a = new Array(5);

Array.apply(null, a);    // ES5
Array.from(a);           // ES6

稀疏数组特性

稀疏数组跟密集数组相比具有以下特性：

• 访问速度慢
• 内存利用率高

这与 V8 引擎构建 JS 对象的方式有关。V8 访问对象有两种模式：字典模式 和 快速模式。

稀疏数组使用的是字典模式，也称为 散列表模式，该模式下 V8 使用散列表来存储对象属性。由于每次访问时都需要计算哈希值（实际上只需要计算一次，哈希值会被缓存）和寻址，所以访问速度非常慢。另一方面，对比起使用一段连续的内存空间来存储稀疏数组，散列表的方式会大幅度地节省内存空间。

而密集数组在内存空间中是被存储在一个连续的类数组里，引擎可以直接通过数组索引访问到数组元素，所以速度会非常快。

这里提供一个 jsperf 测试：

// Sparse Array
var a = [];
a[10000] = 1;
a.forEach(function(){});

// Dense Array
var b = Array.from(a);
b.forEach(function(){});

测试结果：

可见密集数组的访问性能明显比稀疏数组的高，因此建议日常编码中能避免稀疏数组的尽量避免。

遍历稀疏数组

大部分 Array.prototype 上的数组遍历方法，譬如 forEach、map、filter 等方法，在遍历到稀疏数组的缺失元素时，回调函数是不会执行的。

var a = [1,,,,];
a.forEach(i => { console.log(i) });    // 只会打印一次

除此之外，我们需要注意稀疏数组在这些场景下的特殊表现：

• for-in 语句

for-in 语句只会遍历对象的可枚举属性，不会遍历稀疏数组中的缺失元素。

var a = [1,,,,5];
for (var i in a) { console.log(a[i]) };    // 1 5
for (var i of a) { console.log(i) };       // 1 undefined undefined undefined 5

• 判断数组中是否存在 undefined 元素

var a = [1,,,,];
var b = new Array(5);
var c = [];

// 结果符合预期的
a.findIndex(i => i === undefined);    // 1
b.every(i => i === undefined);        // true

// 结果不符合预期的
a.indexOf();                          // -1
a.some(i => i === undefined);         // false

// 比较特殊的
a.includes();                         // true
b.includes();                         // true
c.includes();                         // false

some、every 方法会出现这样的结果，是因为这两者都不会遍历数组中的缺失元素，所以 some 只会返回 false （数组内找不到 undefined 元素）。而 every 在遍历空数组时，会返回 true。

findIndex 方法与 forEach 等遍历方法有所不同，find 和 findIndex 是使用 for 循环实现的，所以无论数组元素是否缺失都可以被遍历到。

includes 方法则比较特殊，我们可以理解为当数组为空时，只会返回 false；而当数组非空（指长度不为0的数组，其中包括全部元素都缺失的数组），且函数调用参数为空时会返回 true。

• map 方法

不会遍历缺失元素，但返回的结果具有与源数组相同的长度和空隙。

var a = [1,,,,5];
a.map(i => i);       // [1, empty × 3, 5]
a.filter(i => i);    // [1, 5]

• sort 方法

不会遍历缺失元素，数组能正常排序，同时会返回与源数组相同的长度。

var a = [5,,,,1];
a.sort();    // [1, 5, empty × 3]

• join 方法

缺失元素占的坑还是会被保留。

var a = new Array(5);
a.join();    // ",,,,"

其他未提及的数组原型方法，在稀疏数组下调用的表现基本与密集数组的一致。