include

include方法直接返回boolean，这个方法应该是最适合判断数组中是否包含某个值，也适用于字符串。

const fruits = ['apple', 'banana', 'cherry'];
const hasBanana = fruits.includes('banana'); // 返回true，因为数组包含'banana'

every

every表示数组中是否每一项满足条件的，如果是就返回true,如果有一项不满足则返回false,终止循环
重名判断用every来解决

const numbers = [2, 4, 6, 8, 10];
const allEvenNumbers = numbers.every((num) => num % 2 === 0); // 返回true，因为数组中所有元素都是偶数

some

some表示数组中是否有一项满足条件的，如果有就返回true,终止循环，如果没有，一直循环到结束，返回false，如果需要判断只要有一项满足就可以使用改方法

const numbers = [1, 2, 3, 4, 5];
const hasEvenNumber = numbers.some((num) => num % 2 === 0); // 返回true，因为数组中有偶数

filter

filter适合获取一个数组中筛选出所有满足条件的结果，返回是一个数组。

const numbers = [1, 2, 3, 4, 5];
const evenNumbers = numbers.filter((num) => num % 2 === 0); // 返回[2, 4]

find

find查找数组中第一个符合条件的元素，找到就返回改项，没有就返回undefined, 此方法和some方法差不多，但是此方法可以把找到的选项信息打印出来。find适合获取一个数组中满足条件的第一个结果，只关心有没有满足条件，不关心数组中有多少个满足。

const numbers = [1, 2, 3, 4, 5];
const evenNumber = numbers.find((num) => num % 2 === 0); // 返回2，第一个满足条件的元素

findindex

findIndex：find的孪生兄弟，这个方法是返回满足条件的第一个元素的索引，如果找不到将返回-1。

const numbers = [1, 2, 3, 4, 5];
const evenNumberIndex = numbers.findIndex((num) => num % 2 === 0); // 返回1，第一个满足条件的元素的索引

indexOf

indexOf() 方法返回数组中第一个匹配元素的索引，如果未找到则返回-1。

const fruits = ['apple', 'banana', 'cherry'];
const index = fruits.indexOf('banana'); // 返回2，因为'banana'在索引2处

lastIndexOf

lastIndexOf() 方法返回数组中最后一个匹配元素的索引，如果未找到则返回-1。

const fruits = ['apple', 'banana', 'cherry', 'banana'];
const lastIndex = fruits.lastIndexOf('banana'); // 返回3，因为最后一个'banana'在索引3处

push

push方法在数组尾部添加元素，返回结果数组的长度，能接收任意数量参数，push() 修改了原数组。

let fruits = ['apple', 'banana'];
let length = fruits.push('orange');
console.log(fruits); // Output: ['apple', 'banana', 'orange']
console.log(length); // Output: 3

pop

pop() 方法移除数组最后一项，返回的是被移除项。修改原数组

let fruits = ['apple', 'banana', 'orange'];
let removedElement = fruits.pop();
console.log(fruits); // Output: ['apple', 'banana']
console.log(removedElement); // Output: 'orange'

shift

shift() 删除数组的第一项元素，返回被删除的元素， 修改原数组

let fruits = ['orange', 'apple', 'banana'];
let removedElement = fruits.shift();
console.log(fruits); // Output: ['apple', 'banana']
console.log(removedElement); // Output: 'orange'

unshift

unshift()向数组的头部添加元素，返回的是结果数组的长度，修改原数组

let fruits = ['apple', 'banana'];
let length = fruits.unshift('orange');
console.log(fruits); // Output: ['orange', 'apple', 'banana']
console.log(length); // Output: 3

toString

toString() 方法将数组转换为字符串，其中数组元素由逗号分隔。

const fruits = ['apple', 'banana', 'cherry'];
const fruitString = fruits.toString(); // 返回 'apple,banana,cherry'

join

join() 方法用于将数组的所有元素连接成一个字符串，并返回该字符串。

let fruits = ['apple', 'banana', 'orange'];
let joinedString = fruits.join(', ');
console.log(joinedString); // Output: 'apple, banana, orange'

reverse

reverse() 方法用于反转数组中的元素顺序。

const numbers = [1, 2, 3, 4, 5];
numbers.reverse(); // 反转后的数组是 [5, 4, 3, 2, 1]

concat

concat() 方法用于合并两个或多个数组，并返回一个新数组。

const arr1 = [1, 2];
const arr2 = [3, 4];
const combinedArray = arr1.concat(arr2); // 返回合并后的新数组，combinedArray是 [1, 2, 3, 4]

slice

slice() 方法返回数组的一部分，根据指定的开始索引和结束索引。

const fruits = ['apple', 'banana', 'cherry', 'date'];
const slicedFruits = fruits.slice(1, 3); // 返回从索引1到2的元素（不包括索引3），slicedFruits是 ['banana', 'cherry']

splice

splice() 方法用于在数组中添加或删除元素，可以同时添加和删除元素。

const fruits = ['apple', 'banana', 'cherry'];
fruits.splice(1, 1, 'orange'); // 从索引1处删除1个元素并插入'orange'，fruits现在是 ['apple', 'orange', 'cherry']

reduce

reduce() 方法从数组的左侧（即从第一个元素开始）向右依次迭代数组的元素，并将它们汇总为一个最终值。

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
console.log(sum); // 输出 15，即 1 + 2 + 3 + 4 + 5

reduceRight

reduceRight() 方法与 reduce() 方法类似，但它从数组的右侧（即从最后一个元素开始）向左依次迭代数组的元素，并将它们汇总为一个最终值。

const numbers = [1, 2, 3, 4, 5];
const concatenatedString = numbers.reduceRight((accumulator, currentValue) => accumulator + currentValue, '');
console.log(concatenatedString); // 输出 "54321"，因为从右向左连接

reduce和reduceRight注意

arr.reduce(callback(accumulator, currentValue, currentIndex, array), initialValue)
arr.reduceRight(callback(accumulator, currentValue, currentIndex, array), initialValue)

• accumulator：累积值，它是上一次迭代的结果或初始值。
• currentValue：当前元素的值。
• currentIndex：当前元素的索引。
• array：原始数组。
• initialValue：可选，初始累积值。

第二个参数的类型会影响累积值的类型和计算方式。如果需要执行数值运算，使用数字作为初始值；如果需要进行字符串拼接或其他字符串操作，使用字符串作为初始值。根据具体的需求，选择合适的初始值类型。

forEach

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

const numbers = [1, 2, 3];
numbers.forEach((num) => {
  console.log(num); // 依次输出1、2、3
});

map

map() 方法创建一个新数组，其中包含原数组中的每个元素经过指定函数处理后的值。

const numbers = [1, 2, 3];
const doubledNumbers = numbers.map((num) => num * 2); // 返回[2, 4, 6]

forEach和map区别

1. 返回值：

• map() 方法会返回一个新的数组，该数组包含了对原始数组中的每个元素应用回调函数后的结果。原始数组不受影响。

const numbers = [1, 2, 3];
const doubledNumbers = numbers.map((num) => num * 2); // 返回 [2, 4, 6]

• forEach() 方法没有返回值（或者说返回 undefined），它只用于遍历数组，执行回调函数，但不会创建新数组或修改原始数组。
• 注意：forEach() 不会修改原始数组的元素值，但它可以在回调函数中修改原始数组的元素，因为回调函数接受三个参数：当前元素的值、当前元素的索引和数组本身。通过这些参数，您可以在 forEach() 中对原始数组的元素进行操作。但需要注意，这样的操作可能会对原始数组产生副作用。

2. 用途：

• map() 主要用于对数组的每个元素进行操作，并返回一个新的数组，通常用于将原始数据映射到新的数据。
• forEach() 主要用于迭代数组的每个元素，执行某些操作，例如输出元素或修改原始数组的内容，但它不会返回新的数组。

3. 副作用：

• map() 是一种纯函数，它不会修改原始数组，而是创建一个新数组，因此不会产生副作用。
• forEach() 可以用于修改原始数组的内容，因此具有潜在的副作用。在回调函数中对原始数组进行修改是可能的，但要小心，以免引发意外行为。

const numbers = [1, 2, 3];

// 使用map创建一个新数组，不影响原数组
const doubledNumbers = numbers.map((num) => num * 2);

// 使用forEach修改原数组
numbers.forEach((num, index, arr) => {
  arr[index] = num * 2;
});

console.log(numbers); // [2, 4, 6]

综上所述，选择使用 map() 还是 forEach() 取决于您的需求。如果您需要创建一个新数组，以保存对原始数组的操作结果，那么 map() 是更合适的选择。如果只需要遍历数组并执行某些操作，而不需要返回新数组，那么 forEach() 可能更合适。此外，请谨慎处理 forEach() 中对原始数组的修改，以避免引发不必要的问题

from

Array.from() 方法用于将类似数组或可迭代对象（例如字符串、Set、Map）转换为真正的数组。

1. 从字符串创建数组：

const str = 'Hello';
const strArray = Array.from(str);
// strArray 是一个数组，它包含字符串 'Hello' 的每个字符作为一个元素：['H', 'e', 'l', 'l', 'o']

2. 从Set创建数组：

const set = new Set([1, 2, 3]);
const setArray = Array.from(set);
// setArray 是一个数组，它包含Set中的元素：[1, 2, 3]

3. 使用映射函数：可以使用可选的映射函数来对转换后的数组中的每个元素进行操作：

const numbers = [1, 2, 3];
const doubledArray = Array.from(numbers, (num) => num * 2);
// doubledArray 是一个数组，它包含每个数字乘以2的结果：[2, 4, 6]

of

Array.of() 方法创建一个包含传入参数的数组。

const numbers = Array.of(1, 2, 3, 4, 5); // 创建包含这些数字的数组

fill

fill() 用于填充数组的所有元素（或一部分元素）为指定的值。这个方法通常用于修改数组的元素，将它们设置为特定的值。

1. 填充整个数组：

const numbers = [1, 2, 3, 4, 5];

// 将整个数组填充为 0
numbers.fill(0);

console.log(numbers); // 输出 [0, 0, 0, 0, 0]

这将把数组中的所有元素都设置为值 0。

2. 填充指定范围的元素：

const numbers = [1, 2, 3, 4, 5];

// 将索引 1 到 3 之间（不包括 3）的元素填充为 10
numbers.fill(10, 1, 3);

console.log(numbers); // 输出 [1, 10, 10, 4, 5]

这将把索引为 1 和 2 的元素设置为值 10，而其他元素保持不变。

3. 使用负数索引：fill() 方法也支持负数索引，负数索引表示从数组的末尾开始计数。

const numbers = [1, 2, 3, 4, 5];

// 将数组的最后两个元素填充为 7
numbers.fill(7, -2);

console.log(numbers); // 输出 [1, 2, 3, 7, 7]

这将把数组中的最后两个元素设置为值 7。

4. 不指定结束索引：如果不指定结束索引，fill() 将填充从起始索引到数组末尾的所有元素。

const numbers = [1, 2, 3, 4, 5];

// 将索引 2 到数组末尾的所有元素填充为 8
numbers.fill(8, 2);

console.log(numbers); // 输出 [1, 2, 8, 8, 8]

这将把索引 2 到数组末尾的所有元素设置为值 8。

copyWithin

copyWithin() 方法在数组内部复制一部分元素，然后粘贴到数组的另一部分，以指定的位置开始。

array.copyWithin(target, start[, end])

• array：需要操作的数组。
• target：必需，表示开始复制元素的目标位置（索引）。
• start：必需，表示开始复制的起始位置（索引）。
• end：可选，表示结束复制的位置（索引）（默认为数组的长度）。

示例：

假设有以下数组：

const numbers = [1, 2, 3, 4, 5];

1. 基本用法：

// 将索引 0 到 2（不包括索引 2）的元素复制到索引 2 开始的位置
numbers.copyWithin(2, 0, 2);
console.log(numbers); // 输出 [1, 2, 1, 2, 5]

在这个示例中，我们从 start 索引0开始，复制到 end 索引2（不包括索引2）的元素，然后将它们粘贴到 target 索引2的位置。结果是数组重新排列了这些元素。

2. 复制到末尾：

// 将索引 0 到 3（不包括索引 3）的元素复制到数组末尾
numbers.copyWithin(numbers.length, 0, 3);
console.log(numbers); // 输出 [1, 2, 3, 1, 2]

在这个示例中，我们将索引0到3（不包括3）的元素复制到数组的末尾，实现了将一段元素追加到数组的效果。

3. 负数索引：

// 将倒数第二个元素复制到第一个位置
numbers.copyWithin(0, -2, -1);
console.log(numbers); // 输出 [4, 2, 3, 4, 5]

在这个示例中，我们使用了负数索引，将倒数第二个元素复制到了数组的第一个位置。

4. 不指定end参数：如果不指定end参数，copyWithin() 将复制到数组末尾。

javascriptCopy code
// 将索引 2 开始的所有元素复制到数组末尾
numbers.copyWithin(numbers.length);

console.log(numbers); // 输出 [1, 2, 3, 4, 5, 3, 4, 5]

在这个示例中，我们从索引2开始复制到数组的末尾，所有元素都被复制并粘贴。

flat

flat()用于将嵌套的子数组展开成一个新的扁平化数组。这个方法的目的是将多层嵌套的数组转换为一个层级的数组，以便更容易处理

1. 简单的数组展开：

const nestedArray = [1, [2, [3, [4, 5]]]];

const flattenedArray = nestedArray.flat();
// 默认情况下，展开一层嵌套的子数组

console.log(flattenedArray); // 输出 [1, 2, [3, [4, 5]]]

在这个示例中，默认情况下，flat() 方法只展开了一层嵌套的子数组。

2. 展开多层嵌套的数组：

const nestedArray = [1, [2, [3, [4, 5]]]];

const deepFlattenedArray = nestedArray.flat(Infinity);
// 使用 Infinity 参数，展开多层嵌套的子数组

console.log(deepFlattenedArray); // 输出 [1, 2, 3, 4, 5]

在这个示例中，我们使用 Infinity 参数来展开多层嵌套的子数组，直到所有嵌套都被展开。

3. 指定展开的深度：

const nestedArray = [1, [2, [3, [4, 5]]]];

const partiallyFlattenedArray = nestedArray.flat(2);
// 指定展开的深度为 2

console.log(partiallyFlattenedArray); // 输出 [1, 2, 3, [4, 5]]

在这个示例中，我们指定了 flat() 方法展开的深度为2，这意味着只展开两层嵌套的子数组。

flatMap

flatMap() 方法首先使用映射函数将每个元素映射到一个新数组，然后将所有结果数组拼接成一个新数组。

1. 简单的映射和展开：

const arr = [1, 2, 3, 4];

const result = arr.flatMap((x) => [x * 2]);
// 使用映射函数将每个元素乘以2，并将结果展开成一个新数组

console.log(result); // 输出 [2, 4, 6, 8]

在这个示例中，映射函数 (x) => [x * 2] 将数组中的每个元素乘以2，并将结果包装在一个子数组中。然后，flatMap() 将这些子数组展开成一个新的扁平数组。

2. 移除空值：

const arr = [1, 2, 3, 4, null, 5];

const result = arr.flatMap((x) => (x === null ? [] : [x]));
// 使用映射函数移除数组中的空值（null）

console.log(result); // 输出 [1, 2, 3, 4, 5]

在这个示例中，映射函数 (x) => (x === null ? [] : [x]) 移除了数组中的空值（null），将非空值包装在子数组中，然后使用 flatMap() 展开这些子数组，得到一个新数组。

3. 处理嵌套数组：

const arr = [[1, 2], [3, 4], [5, 6]];

const result = arr.flatMap((subArray) => subArray);
// 使用映射函数展开嵌套数组

console.log(result); // 输出 [1, 2, 3, 4, 5, 6]

在这个示例中，映射函数 (subArray) => subArray 用于展开嵌套数组，将它们合并成一个新的扁平数组。

总之，flatMap() 方法允许您在映射数组元素时方便地处理嵌套结构，然后将结果扁平化成一个新的数组。这对于处理数组中的嵌套数据非常有用，使代码更清晰和简洁。