数组的查询方法

方法列表

• length
• entries
• inclueds
• indexOf
• keys
• lastIndexOf
• values

length

length 是 Array 的实例属性。返回或设置一个数组中的元素个数。该值是一个无符号 32-bit 整数，并且总是大于数组最高项的下标。

示例

const listA = [1, 2, 3];
const listB = new Array(6);
console.log(listA.length); // 3
console.log(listB.length); // 6
listB.length = 4294967296; // 2 的 32 次方 = 4294967296
// 报错 RangeError: Invalid array length
const listC = new Array(-100) // 负数
// 报错 RangeError: Invalid array length

巧用

数组的 length 属性可以赋值，具有截断和扩展作用

• 使用扩展操作时，即赋值之后的 length 大于 赋值前的，则会变成稀疏数组，使用 empty 来占位
• 使用截断操作时，即赋值之后的 length 小于 赋值前的，则会直接删除多余的末尾元素

const list = [1, 2, 3, 4, 5,]
console.log(list.length) // 5
list.length = 3
console.log(list, list.length) // [1, 2, 3] 3
list.length = 6
console.log(list, list.length) // [1, 2, 3, empty × 3] 6

entries

entries 方法返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。

详情请见 iterator 对象

参数说明

entries () return Array Iterator

示例

var arr = ["a", "b", "c"];
var iterator = arr.entries();
// undefined
for (let e of iterator) {
  console.log(e);
    // [0, "a"]
    // [1, "b"]
    // [2, "c"]
}

inclueds

includes 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。

参数说明

inclued (
  searchElement: T,
  fromIndex: number | undefined // [
): boolean

示例

[1, 2, 3].includes(2);     // true
[1, 2, 3].includes(4);     // false
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true

如果 fromIndex 大于等于数组的长度，则将直接返回 false，且不搜索该数组。

var arr = ['a', 'b', 'c'];
arr.includes('c', 3);   // false
arr.includes('c', 100); // false

如果 fromIndex 为负值，计算出的索引将作为开始搜索searchElement的位置。如果计算出的索引小于 0，则整个数组都会被搜索。

var arr = ['a', 'b', 'c'];
arr.includes('a', -100); // true
arr.includes('b', -100); // true
arr.includes('c', -100); // true
arr.includes('a', -2);   // false

indexOf

indexOf 方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

参数说明

indexOf (
  searchElement: number,
  fromIndex: number | undefined // [
): number

示例

var array = [2, 5, 9];
array.indexOf(2);     // 0
array.indexOf(7);     // -1
array.indexOf(9, 2);  // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0

indexOf 查询是是使用严格相等的

const arr = [1, 2, 3, 4, 5,]
console.log(arr.indexOf('1')) // -1

keys

keys 方法返回一个包含数组中每个索引键的**Array Iterator**对象。

参数说明

keys () return Array Iterator 对象

示例

索引迭代器会包含那些没有对应元素的索引

var arr = ["a", , "c"];
var sparseKeys = Object.keys(arr);
var denseKeys = [...arr.keys()];
console.log(sparseKeys); // ['0', '2']
console.log(denseKeys);  // [0, 1, 2]

lastIndexOf

lastIndexOf 方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。

使用方法与同 indexOf

values

values 方法返回一个新的 **Array Iterator** 对象，该对象包含数组每个索引的值。

参数说明

values () return Array Iterator 对象

示例

使用 for of 进行迭代

const arr = ['a', 'b', 'c', 'd', 'e'];
const iterator = arr.values();
for (let letter of iterator) {
  console.log(letter);
}  //"a" "b" "c" "d" "e"
// 当然也可以写作 效果也是相同的
for (let letter of arr.values()) {
  console.log(letter);
}

使用 .next 进行迭代

数组迭代器是一次性的，或者说临时对象

const arr = ['a', 'b', 'c', 'd', 'e'];
const iterator = arr.values();
iterator.next();               // Object { value: "a", done: false }
iterator.next().value;         // "b"
iterator.next()["value"];      // "c"
iterator.next();               // Object { value: "d", done: false }
iterator.next();               // Object { value: "e", done: false }
iterator.next();               // Object { value: undefined, done: true }
iterator.next().value;         // undefined