数组的常用方法

创建和初始化数组

使用 Array 构造函数初始化

let array1 = new Array();
let array2 = new Array(7);
let array3 = new Array('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday');

直接赋值创建

let array1 = [];
let array2 = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];

Array.of 方法

Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。

let array1 = Array.of(7); // [7]
let array2 = Array.of(...[1, 2, 3, 4]); // [1, 2, 3, 4]

二维和多维数组

二维数组

let matrixArray = new Array(2);
matrixArray[0] = new Array('0.0', '0.1', '0.2', '0.3');
matrixArray[1] = new Array('1.0', '1.1', '1.2', '1.3');

-	[0]	[1]	[2]	[3]
[0]	‘0.0’	‘0.1’	‘0.2’	‘0.3’
[1]	‘1.0’	‘1.1’	‘1.2’	‘1.3’

搜索元素

使用 indexOf 方法

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

let array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10];
console.log(array.indexOf(10)) // 9
console.log(array.indexOf('A')) // -1

使用 lastIndexOf 方法

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

let array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10];
console.log(array.lastIndexOf(10)) // 10
console.log(array.indexOf('A')) // -1

console.log(array.lastIndexOf(10, 9)) // 9

使用 find 方法

find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。

let array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10];

let find1 = array.find((value, index, arr) => {
    return value % 2 === 0;
}) // 2

let find2 = array.find((value, index, arr) => {
    return typeof value === 'string';
}) // undefined

使用 findIndex 方法

findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。

let array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10];

let find1 = array.findIndex((value, index, arr) => {
    return value % 2 === 0;
}) // 1

let find2 = array.findIndex((value, index, arr) => {
    return typeof value === 'string';
}) // -1

使用 includes 方法

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

let array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10];
console.log(array.includes(10)) // true
console.log(array.includes('A')) // false

添加元素

使用 push 方法

push 方法，能把任意元素添加到数组的末尾。

let array = [1, 2, 3];
array.push('number'); //[1, 2, 3, 'number']

使用 unshfit 方法

unshfit 方法，能把任意元素添加至数组的开头。

let array = [1, 2, 3];
array.unshfit('number1', 'number2'); // ['number1', 'number2', 1, 2, 3]

删除元素

使用 pop 方法

pop 方法，能在数组的末尾删除一个元素。

let array = [1, 2, 3, 'number'];
array.pop(); // [1, 2, 3]

使用 shfit 方法

shfit方法，能在数组的开头删除一个元素。

let array = [ 'number', 1, 2, 3];
array.shfit(); // [1, 2, 3]

在任意位置删除、添加、替换元素

使用 splice 删除元素

let array = [1, 2, 3, 4, 5];
array.splice(0, 3); // [4, 5];

使用 splice 添加元素

let array = [1, 2, 3];
let insertArray = ['number1', 'number2']
array.splice(1, 0, ...insertArray); // [1, 'number1', 'number2', 2, 3];

使用 splice 替换元素

let array = [1, 2, 3];
let replaceArray = ['number1', 'number2']
array.splice(1, 1, ...replaceArray); // [1, 'number1', 'number2', 3];

使用 fill 替换元素

fill() 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。

let array = [1, 2, 3];
let number = 0;
array.fill(number, 1, 3); // [1, 0, 0]

数组合并

使用 concat 连接数组

concat 函数并不会直接改变数组的值，而是返回一个连接后的数组

let array1 = [1, 2, 3];
let array2 = ['a', 'b', 'c'];
let result = array1.concat(array2); // [1, 2, 3, 'a', 'b', 'c']

排序元素

使用 sort 方法排序

let array = [5, 3, 2, 1, 4];
array.sort(); // [1, 2, 3, 4, 5]

使用 sort 方法自定义排序

let array = ['D', 'a', 'c', 'B'];
array.sort(); // ['B', 'D', 'a', 'c']

let strCompare = (one, two) => {
  if (one.toLowerCase() < b.toLowerCase()) {
    return -1;
  }
  if (one.toLowerCase() > b.toLowerCase()) {
    return 1;
  }
  return 0;
}
array.sort(strCompare); // ['a', 'B', 'c' 'D']

使用 reverse 方法将数组中元素的位置颠倒

let array = [1, 2, 3, 4, 5];
array.reverse(); // [5, 4, 3, 2, 1]

迭代器函数

forEach 方法

forEach( ) 方法对数组的每个元素执行一次提供的函数。

let array = [1, 2, 3, 4];
array.forEach((value, index, arr) => {
  console.log(value % 2 === 0); // 输入出是否被 2 整除
})
// false
// true
// false
// true

for …… of 循环迭代

let array = [1, 2, 3, 4];
for (const number of array) {
  console.log(n % 2 === 0)
}
// false
// true
// false
// true

map 方法

map() 方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。

let array = [1, 2, 3, 4];
let result = array.forEach((value, index, arr) => {
  return value * 2;
})
// array : [1, 2, 3, 4]
// result : [2, 4, 6, 8]

filter 方法

filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

let array = [1, 2, 3, 4];
let result = array.filter((value, index, arr) => {
  return value > 2;
})
// array : [1, 2, 3, 4]
// result : [3, 4]

reduce 方法

reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

let array = [1, 2, 3, 4];
let result = array.reduce((value, currentValue, index, arr) => {
  return value + currentValue;
}, 5)
// result : 5 + 1 + 2 + 3 + 4 = 15

every 方法

every( )方法测试数组的所有元素是否都通过了指定函数的测试。

let array = [1, 2, 3, 4];

array.every((value) => {
  return value % 2 === 0; // 数组是否都能被 2 整除
})
// false

array.every((value) => {
  return typeof value == 'number'; // 数组是否都是数字
})
// true

some 方法

some() 方法测试是否至少有一个元素通过由提供的函数实现的测试。

let array = [1, 2, 3, 4];

array.some((value) => {
  return value % 2 === 0; // 数组有没有能被 2 整除的值
})
// true

array.some((value) => {
  return typeof value == 'string'; // 数组有没有字符串
})
// false

entries 方法

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

let array = [1, 2, 3, 4];
let iterator = array.entries();

console.log(iterator.next()); // {value: [0, 1], done: false }
console.log(iterator.next()); // {value: [1, 2], done: false }
console.log(iterator.next()); // {value: [2, 3], done: false }
console.log(iterator.next()); // {value: [3, 4], done: false }
console.log(iterator.next()); // {value: undefined, done: true }

keys 方法

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

let array = [1, 2, 3, 4];
let iterator = array.keys();

console.log(iterator.next()); // {value: 0, done: false }
console.log(iterator.next()); // {value: 1, done: false }
console.log(iterator.next()); // {value: 2, done: false }
console.log(iterator.next()); // {value: 3, done: false }
console.log(iterator.next()); // {value: undefined, done: true }

values 方法

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

let array = [1, 2, 3, 4];
let iterator = array.values();

console.log(iterator.next()); // {value: 1, done: false }
console.log(iterator.next()); // {value: 2, done: false }
console.log(iterator.next()); // {value: 3, done: false }
console.log(iterator.next()); // {value: 4, done: false }
console.log(iterator.next()); // {value: undefined, done: true }

Array.from 方法

Array.from() 方法从一个类似数组或可迭代对象中创建一个新的数组实例。

console.log(Array.from('number')); // ['n', 'u', 'm', 'b', 'e', 'r']
console.log(Array.from([1, 2, 3], value => value + 1)); // [2, 3, 4]

输出数组为字符串

toString 方法

let array = ['h', 'e', 'l', 'l', 'o'];
console.log(array.toString()); // 'h, e, l, l, o'

join 方法

let array = ['h', 'e', 'l', 'l', 'o'];
console.log(array.join('-')); // 'h-e-l-l-o'