当涉及到数组的方法时，可以将它们分为以下几个分类：

1.修改原数组的方法：

`push()`

在 push() 方法中，我们可以传入一个或多个元素作为参数，这些元素将被添加到数组的末尾，并返回新数组的长度。

使用示例

c 复制代码

const array = [1, 2, 3];
const length = array.push(4, 5);
console.log(array); // 输出: [1, 2, 3, 4, 5]
console.log(length); // 输出: 5

在上述示例中，我们向数组 array 的末尾添加了两个元素 4 和 5，并通过 push() 方法返回的长度来获取新数组的长度。

需要注意的是

push() 方法会修改原始数组，并返回新数组的长度。如果你不需要获取新数组的长度，只需将元素添加到数组末尾，可以直接调用 push() 方法。

`pop()`

在 pop() 方法中，不需要传入任何参数。它会自动移除数组的最后一个元素，并将该元素返回。

使用示例

c 复制代码

const array = [1, 2, 3, 4, 5];
const lastElement = array.pop();
console.log(lastElement); // 输出: 5
console.log(array); // 输出: [1, 2, 3, 4]

在上述示例中，我们从数组 array 中移除了最后一个元素 5，并通过 pop() 方法返回了这个元素。数组的长度随之减少。

需要注意的是

pop() 方法会修改原始数组。如果数组为空，pop() 方法将返回 undefined。

`shift()`

在 shift() 方法中，不需要传入任何参数。它会自动移除数组的第一个元素，并将该元素返回。这个操作会改变数组的长度。

使用示例

c 复制代码

const array = [1, 2, 3, 4, 5];
const firstElement = array.shift();
console.log(firstElement); // 输出: 1
console.log(array); // 输出: [2, 3, 4, 5]

在上述示例中，我们从数组 array 中移除了第一个元素 1，并通过 shift() 方法返回了这个元素。数组的长度随之减少。

需要注意的是

shift() 方法会修改原始数组。如果数组为空，shift() 方法将返回 undefined。

`unshift()`

在 unshift() 方法中，你可以传入一个或多个元素作为参数，这些元素将被添加到数组的开头，并返回新数组的长度。

使用示例

c 复制代码

const array = [1, 2, 3];
const newLength = array.unshift(0);
console.log(array); // 输出: [0, 1, 2, 3]
console.log(newLength); // 输出: 4

在上述示例中，我们向数组 array 的开头添加了元素 0，并通过 unshift() 方法返回的新数组长度来获取更新后的数组长度。

需要注意的是

unshift() 方法会修改原始数组，并返回新数组的长度。这个方法可以一次添加多个元素，从而使得数组的元素顺序发生改变。

`splice()`

splice() 方法用于添加、删除或替换数组中的元素。这个方法可以同时进行添加和删除操作，并且会直接修改原数组。

基本语法

c 复制代码

array.splice(start, deleteCount, item1, item2, ..., itemN);

start: 指定修改的开始位置（数组索引）。
deleteCount: 指定应该删除多少元素（如果设置为0，则不删除元素）。
item1, item2, ..., itemN: （可选）指定要添加到数组中的新元素。

删除元素

c 复制代码

const array = [1, 2, 3, 4, 5];
const removed = array.splice(2, 2); // 从索引2开始删除2个元素
console.log(array); // 输出: [1, 2, 5]
console.log(removed); // 输出: [3, 4]，被删除的元素

添加元素

c 复制代码

const array = [1, 2, 3, 4, 5];
array.splice(2, 0, 'a', 'b'); // 从索引2开始，删除0个元素，添加'a'和'b'
console.log(array); // 输出: [1, 2, 'a', 'b', 3, 4, 5]

替换元素

c 复制代码

const array = [1, 2, 3, 4, 5];
array.splice(2, 1, 'replace'); // 从索引2开始，删除1个元素，添加'replace' 
console.log(array); // 输出: [1, 2, 'replace', 4, 5]

需要注意的是

splice() 方法会改变原数组，返回被删除的元素数组。
如果 start 参数大于数组长度，start 会被设置成数组长度。
如果 deleteCount 未定义或大于从 start 到数组末尾的元素数量，则从 start 到数组末尾的所有元素都会被删除。
如果 deleteCount 是0或负数，则不会删除元素。这时，至少应添加一个新元素。

`reverse()`

reverse() 方法用于反转数组中元素的顺序，它会直接在原数组上进行操作，改变原数组，并返回反转后的数组。

使用示例

c 复制代码

const array = [1, 2, 3, 4, 5];
const reversedArray = array.reverse();
console.log(reversedArray); // 输出: [5, 4, 3, 2, 1]
console.log(array); // 输出: [5, 4, 3, 2, 1]

在上述示例中，我们调用了 reverse() 方法，它反转了数组 array 的元素顺序。注意，reverse() 方法返回的是原数组的引用，因此 reversedArray 和 array 显示的是同一个反转后的数组。

需要注意的是

reverse() 方法会改变原数组，所以原数组和方法返回的数组是同一个数组。
如果需要保留原数组的顺序，可以先复制原数组再调用 reverse() 方法。

`sort()`

sort() 方法用于对数组的元素进行排序。默认情况下，sort() 会将数组元素转换为字符串，并按照字符串的字典顺序进行排序。这个方法会直接修改原数组，并返回排序后的数组。

基本语法

ini 复制代码

array.sort([compareFunction]);

compareFunction（可选）: 一个用来定义排序顺序的比较函数。该函数应有两个参数，通常表示为 a 和 b。根据函数返回的值（负数、0、正数），sort() 方法会相应地决定元素的顺序。

默认行为

不提供比较函数时，元素按照转换为字符串的各个字符的`Unicode``位点进行排序。

c 复制代码

const array = [10, 2, 15, 1, 12];
array.sort();
console.log(array); // 输出: [1, 10, 12, 15, 2]

这里的排序逻辑是：

1 的 Unicode 码点比 2 小。
10 转换为字符串后为 10，在 Unicode 字典顺序中，10 会排在 2 前面，因为 1 的码点比 2 的码点小。
同理，12 和 15 也会根据第一个字符 1 的码点进行排序，并且都会排在 2 前面。

使用比较函数

为了按照数值大小排序，可以提供一个比较函数：

c 复制代码

const array = [10, 2, 15, 1, 12];
array.sort(function(a, b) {
  return a - b;
});
console.log(array); // 输出: [1, 2, 10, 12, 15]

如果 compareFunction(a, b) 返回小于 0 的值，a 会被排在 b 前面。
如果返回 0，a 和 b 的顺序不变。
如果返回大于 0 的值，b 会被排在 a 前面。

逆序排序

要逆序排序，可以简单地反转比较函数的返回值：

c 复制代码

const array = [10, 2, 15, 1, 12];
array.sort(function(a, b) {
  return b - a;
});
console.log(array); // 输出: [15, 12, 10, 2, 1]

需要注意的是

sort() 方法会直接修改原数组，而不是创建一个新的数组。
对于非数值排序，可能需要更复杂的比较逻辑来处理不同数据类型或结构。

coyWithin()

copyWithin() 方法用于在数组内部将一部分元素序列复制到另一个位置，而不改变数组的大小。这个方法会修改原数组。

基本语法

sql 复制代码

array.copyWithin(target, start, end);

target: 从该位置开始替换数据。如果为负值，表示倒数。
start（可选）: 从该位置开始读取数据，默认为0。如果为负值，表示从数组末尾开始的倒数第几位。
end（可选）: 在该位置停止读取数据（不包括该位置），默认为数组长度。如果为负值，表示从数组末尾开始的倒数第几位。

基本使用

c 复制代码

const array = [1, 2, 3, 4, 5];
array.copyWithin(0, 3);
console.log(array); // 输出: [4, 5, 3, 4, 5]

在这个示例中，copyWithin() 方法从索引3开始复制数据（元素4和5），然后从索引0开始覆盖原数组的元素。

使用负索引

c 复制代码

const array = [1, 2, 3, 4, 5];
array.copyWithin(0, -2);
console.log(array); // 输出: [4, 5, 3, 4, 5]

这个示例与上一个示例相似，但使用负索引来指定从数组末尾开始的第二个位置开始复制数据。

指定结束位置

c 复制代码

const array = [1, 2, 3, 4, 5];
array.copyWithin(1, 3, 4);
console.log(array); // 输出: [1, 4, 3, 4, 5]

在这个示例中，copyWithin() 方法从索引3开始复制数据，到索引4结束（不包括索引4的元素），然后从索引1开始覆盖原数组的元素。

需要注意的是

copyWithin() 方法会修改原数组。
copyWithin() 处理的是数组内部的浅复制，因此复制和替换的是元素的引用，而不是元素本身（对于引用类型而言）。
如果start和end指定的范围重叠了target的位置，复制的结果将根据重叠的部分来调整。

2.返回新数组的方法：

`concat()`

concat() 方法用于连接两个或多个数组，并返回一个新的数组，而不会修改原始数组。这个方法可以接受任意数量的数组或值作为参数，并将它们顺序连接到一起。

基本语法

ini 复制代码

const newArray = array1.concat(array2, array3, ..., arrayN);

array1, array2, ..., arrayN: 这些是要连接的数组。你也可以在参数中直接包含值，这些值将被添加到返回的新数组中。

连接两个数组

ini 复制代码

const array1 = [1, 2, 3];
const array2 = [4, 5, 6];
const combinedArray = array1.concat(array2);
console.log(combinedArray); // 输出: [1, 2, 3, 4, 5, 6]

在这个示例中，array1 和 array2 被连接成一个新的数组 combinedArray。

连接多个数组

ini 复制代码

const array1 = [1, 2];
const array2 = [3, 4];
const array3 = [5, 6];
const combinedArray = array1.concat(array2, array3);
console.log(combinedArray); // 输出: [1, 2, 3, 4, 5, 6]

这个示例展示了如何将三个数组连接成一个新的数组。

添加额外的元素

ini 复制代码

<JAVASCRIPT>
const array1 = [1, 2, 3];
const extraElement = 4;
const combinedArray = array1.concat(extraElement);
console.log(combinedArray); // 输出: [1, 2, 3, 4]

在这个示例中，不仅数组被连接，单个元素 4 也被添加到了新数组的末尾。

需要注意的是

concat() 方法不会修改原始数组，而是返回一个新的数组。
如果任何参数是数组，concat() 会添加其元素到新数组中；如果参数不是数组，则该参数本身会被添加到新数组中。
concat() 方法可以用来浅拷贝数组，因为它创建了一个新的数组实例。

`slice()`

slice() 方法用于提取原数组的一部分，返回一个新的数组，原数组不会被修改。这个方法可以接受两个参数，分别指定开始和结束的索引，用于控制提取数组的部分。

基本语法

ini 复制代码

const newArray = array.slice(start, end);

start（可选）: 开始位置的索引。如果省略，默认为0，即从数组的第一个元素开始。
end（可选）: 结束位置的索引（不包括该位置）。如果省略，默认为数组的长度，即提取到数组的末尾。

提取数组的一部分

ini 复制代码

const array = [1, 2, 3, 4, 5];
const partArray = array.slice(1, 3);
console.log(partArray); // 输出: [2, 3]

在这个示例中，slice() 方法从索引1开始提取，到索引3结束（不包括索引3的元素），因此结果是 [2, 3]。

使用负数索引

ini 复制代码

const array = [1, 2, 3, 4, 5];
const partArray = array.slice(-3, -1);
console.log(partArray); // 输出: [3, 4]

当使用负数索引时，slice() 方法会从数组末尾开始计数。在这个示例中，从倒数第三个元素开始到倒数第一个元素之前结束。

省略结束索引

ini 复制代码

const array = [1, 2, 3, 4, 5];
const partArray = array.slice(2);
console.log(partArray); // 输出: [3, 4, 5]

如果省略第二个参数（结束索引），slice() 方法会提取从开始索引到数组末尾的所有元素。

需要注意的是

slice() 方法返回的新数组是原数组的浅拷贝。数组中的对象仍然是引用。
如果开始索引大于数组的长度，返回一个空数组。
slice() 方法不会修改原始数组，而是返回一个新的数组。

`map()`

map方法用于对数组的每个元素执行指定的操作，并返回一个新的数组，新数组的元素是原数组经过操作后的结果。

基本语法

c 复制代码

const newArray = array.map(function(element, index, array) { // 对每个元素执行操作，并返回新的值
    return modifiedElement;
});

在map方法中，我们传入一个回调函数作为参数。该回调函数接受三个参数：当前元素的值element、当前元素的索引index和正在遍历的数组array。

在回调函数中，我们对每个元素执行操作，并返回经过操作后的新值modifiedElement。map方法会遍历数组的每个元素，并将每个元素经过回调函数处理后的结果组成一个新的数组。

下面是一个使用map方法的示例：

c 复制代码

const newArray = array.map(function(element) { // 对每个元素执行操作，并返回新的值
    return element * 2;
});

在上述示例中，我们使用map方法对数组array的每个元素进行操作，将每个元素乘以2，并将操作后的结果组成一个新的数组newArray。

需要注意的是

map方法不会修改原始数组，而是返回一个新的数组。
map方法无法遍历对象，仅适用于数组的遍历。
map方法不会对空数组进行检测；

`filter()`

filter方法用于筛选数组中满足指定条件的元素，并返回一个新的数组。

基本语法

c 复制代码

const newArray = array.filter(function(element, index, array) { // 返回一个布尔值，表示是否保留该元素 },thisArg);

在filter方法中，我们传入一个回调函数作为参数。该回调函数接受三个参数：当前元素的值element、当前元素的索引index和正在遍历的数组array。thisArg是可选的参数，用于指定回调函数中的this值。如果省略了thisArg参数，回调函数中的this将指向全局对象（在浏览器中为window对象）。

在回调函数中，我们根据指定的条件判断是否保留该元素。如果回调函数返回true，则该元素将被保留在新的数组中；如果返回false，则该元素将被过滤掉。

下面是一个使用filter方法的示例：

ini 复制代码

const array = [1, 2, 3, 4, 5];
const newArray = array.filter(function(element) { // 返回一个布尔值，表示是否保留该元素
    return element % 2 === 0; // 保留偶数元素
});
console.log(newArray); // 输出: [2, 4]

在上述示例中，我们使用filter方法筛选数组array中的偶数元素，并将满足条件的元素组成一个新的数组newArray。

filter方法非常灵活，可以根据不同的条件筛选数组中的元素。回调函数应该返回一个布尔值，表示是否保留该元素。返回true表示保留，返回false表示过滤掉。

需要注意的是

filter方法会返回一个新的数组，该数组包含满足指定条件的元素。请确保在回调函数中返回一个布尔值，表示是否保留该元素。
filter方法不会对空数组进行检测。

`flat()`

flat() 方法用于将嵌套的数组结构"压平"，即将多层嵌套的数组合并成一个单一的数组。这个方法返回一个新的数组，原数组不会被修改。

基本语法

ini 复制代码

const newArray = array.flat(depth);

depth（可选）: 指定要压平的深度，默认为1。如果设置为2或更高，将递归地压平到指定的深度。

压平一层

ini 复制代码

<JAVASCRIPT>
const array = [1, 2, [3, 4]];
const flatArray = array.flat();
console.log(flatArray); // 输出: [1, 2, 3, 4]

在这个示例中，flat() 方法压平了数组中的一层嵌套。

压平多层

ini 复制代码

const array = [1, 2, [3, 4, [5, 6]]];
const flatArray = array.flat(2);
console.log(flatArray); // 输出: [1, 2, 3, 4, 5, 6]

这里，flat() 方法被指定了深度2，因此它压平了两层嵌套的数组。

使用Infinity压平所有层

ini 复制代码

const array = [1, [2, [3, [4, [5]]]]];
const flatArray = array.flat(Infinity);
console.log(flatArray); // 输出: [1, 2, 3, 4, 5]

使用 Infinity 作为深度参数，可以压平任意深度的嵌套数组。

需要注意的是

flat() 方法不会修改原始数组，而是返回一个新的数组。
如果数组中包含空位，flat() 方法会移除这些空位。

`flatMap()`

flatMap() 方法用于先映射每个元素使用映射函数，然后将结果压平一层，返回一个新的数组。这个方法结合了 map() 和 flat() 的功能，但只遍历数组一次，提高了效率。

基本语法

c 复制代码

const newArray = array.flatMap(function(element, index, array) {
  // 对每个元素执行操作，并返回新的值（可以是数组）
  return modifiedElement;
});

element: 当前元素的值。
index（可选）: 当前元素的索引。
array（可选）: 正在遍历的数组。

映射并压平

ini 复制代码

const array = [1, 2, 3, 4];
const newArray = array.flatMap(function(x) {
  return [x, x * 2];
});
console.log(newArray); // 输出: [1, 2, 2, 4, 3, 6, 4, 8]

在这个示例中，每个数组元素被映射到一个包含该元素及其两倍的新数组，然后 flatMap() 将这些数组压平成一个新数组。

处理字符串数组

lua 复制代码

const array = ['it is', 'a sunny day'];
const newArray = array.flatMap(function(phrase) {
  return phrase.split(' ');
});
console.log(newArray); // 输出: ['it', 'is', 'a', 'sunny', 'day']

这个示例展示了如何将数组中的字符串分割成单词，并将分割后的数组压平。

需要注意的是

flatMap() 只能压平一层。
如果回调函数返回的不是数组，这些值将被直接插入到新数组中。
flatMap() 方法不会修改原始数组，而是返回一个新的数组。

3.遍历数组的方法：

`forEach()`

forEach() 方法用于遍历数组的每个元素并执行指定的回调函数。这个方法不返回值（即返回undefined），并且通常用于执行数组中每个元素的副作用操作。

基本语法

c 复制代码

array.forEach(function(element, index, array) {
  // 对每个元素执行操作
});

在 forEach() 方法中，我们传入一个回调函数作为参数。该回调函数可以接受三个参数：

element: 当前元素的值。
index（可选）: 当前元素的索引。
array（可选）: 正在遍历的数组。

基本使用

c 复制代码

const array = [1, 2, 3, 4, 5];
array.forEach(function(element) {
  console.log(element);
});
// 输出:
// 1
// 2
// 3
// 4
// 5

在这个示例中，forEach() 方法遍历数组 array 的每个元素，并在控制台打印每个元素。

使用索引和数组

javascript 复制代码

const array = ['a', 'b', 'c'];
array.forEach(function(element, index, array) {
  console.log(`Element at index ${index} is ${element}`);
});
// 输出:
// Element at index 0 is a
// Element at index 1 is b
// Element at index 2 is c

这个示例展示了如何在回调函数中使用元素、索引和数组本身。

需要注意的是

forEach() 方法不会修改原数组，但回调函数内的操作可能会修改。
forEach() 方法会遍历数组中的每个元素，即使元素是undefined或空位。
forEach() 方法无法中断，除非抛出异常。如果需要提前终止循环，可能需要使用其他循环方法如for循环或for...of循环。
forEach() 方法不返回值，它的返回值永远是undefined。

`some()`

some() 方法用于检测数组中是否至少有一个元素满足指定条件。它通过提供的函数测试数组中的元素，一旦找到第一个满足条件的元素，就返回true，否则如果没有任何元素满足条件，则返回false。

基本语法

c 复制代码

const result = array.some(function(element, index, array) {
  // 返回一个布尔值，表示是否满足条件
});

在some()方法中，我们传入一个回调函数作为参数。该回调函数接受三个参数：

element: 当前元素的值。
index（可选）: 当前元素的索引。
array（可选）: 正在遍历的数组。

检查数组中是否存在大于某个值的元素

ini 复制代码

const array = [1, 2, 3, 4, 5];
const hasLargeNumber = array.some(function(element) {
  return element > 3;
});
console.log(hasLargeNumber); // 输出: true

在这个示例中，some() 方法检查数组中是否存在大于3的元素。由于数组中包含4和5，因此返回true。

检查数组中是否有偶数

ini 复制代码

const array = [1, 3, 5, 7, 9];
const hasEven = array.some(function(element) {
  return element % 2 === 0;
});
console.log(hasEven); // 输出: false

这个示例检查数组中是否存在偶数。由于所有元素都是奇数，所以返回false。

需要注意的是

some() 方法不会修改原数组。
some() 方法会为数组中的每个元素执行一次回调函数，直到找到一个使回调函数返回true的元素。如果找到这样的元素，some()将立即返回true。
如果数组为空，some() 方法会立即返回false。
some() 方法不会为那些已删除或从未被赋值的元素调用回调函数。

`every()`

every() 方法用于检测数组中的所有元素是否都满足指定条件。它通过提供的函数测试数组中的每个元素，只有当所有元素都使回调函数返回true时，every()才返回true；如果任何一个元素使回调函数返回false，则every()立即返回false。

基本语法

c 复制代码

const result = array.every(function(element, index, array) {
  // 返回一个布尔值，表示是否满足条件
});

在every()方法中，我们传入一个回调函数作为参数。该回调函数接受三个参数：

element: 当前元素的值。
index（可选）: 当前元素的索引。
array（可选）: 正在遍历的数组。

检查数组中所有元素是否大于某个值

ini 复制代码

const array = [4, 5, 6, 7, 8];
const allGreaterThanThree = array.every(function(element) {
  return element > 3;
});
console.log(allGreaterThanThree); // 输出: true

在这个示例中，every() 方法检查数组中的所有元素是否都大于3。由于数组中的每个元素都满足这个条件，因此返回true。

检查数组中所有元素是否为偶数

ini 复制代码

const array = [2, 4, 6, 8, 10];
const allEven = array.every(function(element) {
  return element % 2 === 0;
});
console.log(allEven); // 输出: true

这个示例检查数组中的所有元素是否都是偶数。由于所有元素都是偶数，所以返回true。

需要注意的是

every() 方法不会修改原数组。
every() 方法会为数组中的每个元素执行一次回调函数，直到找到一个使回调函数返回false的元素。如果找到这样的元素，every()将立即返回false。
如果数组为空，every() 方法会立即返回true。
every() 方法不会为那些已删除或从未被赋值的元素调用回调函数。

`find()`

find() 方法用于查找数组中第一个满足指定测试函数的元素。一旦找到符合条件的元素，方法会立即返回该元素的值，否则如果没有找到符合条件的元素，返回undefined。

基本语法

c 复制代码

const foundElement = array.find(function(element, index, array) {
  // 返回一个布尔值，表示当前元素是否满足条件
});

在find()方法中，我们传入一个回调函数作为参数。该回调函数接受三个参数：

element: 当前正在处理的元素。
index（可选）: 当前元素的索引。
array（可选）: 调用find方法的数组。

查找数组中的第一个偶数

ini 复制代码

const array = [1, 3, 4, 6, 7, 8];
const firstEven = array.find(function(element) {
  return element % 2 === 0;
});
console.log(firstEven); // 输出: 4

在这个示例中，find() 方法被用来查找数组中的第一个偶数。一旦找到第一个满足条件（即元素能被2整除）的元素，该元素的值（4）就被返回。

查找数组中的第一个大于10的元素

ini 复制代码

const array = [7, 8, 9, 10, 11, 12];
const firstLargeNumber = array.find(function(element) {
  return element > 10;
});
console.log(firstLargeNumber); // 输出: 11

这个示例查找数组中第一个大于10的元素。当找到元素11时，find() 方法返回这个值。

需要注意的是

find() 方法不会改变原数组。
find() 方法会按顺序遍历数组，直到找到第一个满足条件的元素为止。如果数组中没有元素满足条件，则返回undefined。
find() 方法对于空数组总是返回undefined。
find() 方法不会跳过已删除或未初始化的索引。

`findIndex()`

findIndex() 方法用于查找数组中第一个满足指定测试函数的元素的索引。如果找到符合条件的元素，该方法会立即返回该元素的索引；如果没有找到符合条件的元素，返回 -1。

基本语法

c 复制代码

const foundIndex = array.findIndex(function(element, index, array) {
  // 返回一个布尔值，表示当前元素是否满足条件
});

在findIndex()方法中，我们传入一个回调函数作为参数。该回调函数接受三个参数：

element: 当前正在处理的元素。
index（可选）: 当前元素的索引。
array（可选）: 调用findIndex方法的数组。

查找数组中的第一个偶数的索引

ini 复制代码

const array = [1, 3, 4, 6, 7, 8];
const firstEvenIndex = array.findIndex(function(element) {
  return element % 2 === 0;
});
console.log(firstEvenIndex); // 输出: 2

在这个示例中，findIndex() 方法被用来查找数组中的第一个偶数的索引。一旦找到第一个满足条件（即元素能被2整除）的元素，该元素的索引（2）就被返回。

查找数组中的第一个大于10的元素的索引

ini 复制代码

const array = [7, 8, 9, 10, 11, 12];
const firstLargeNumberIndex = array.findIndex(function(element) {
  return element > 10;
});
console.log(firstLargeNumberIndex); // 输出: 4

这个示例查找数组中第一个大于10的元素的索引。当找到元素11时，findIndex() 方法返回这个元素的索引（4）。

注意事项

findIndex() 方法不会改变原数组。
findIndex() 方法会按顺序遍历数组，直到找到第一个满足条件的元素为止。如果数组中没有元素满足条件，则返回-1。
findIndex() 方法对于空数组总是返回-1。
findIndex() 方法不会跳过已删除或未初始化的索引。

4.元素定位的方法：

`indexOf()`

indexOf() 方法是JavaScript数组对象的一个内置方法，用于搜索数组中的元素，并返回该元素在数组中首次出现的索引。如果没有找到元素，则返回 -1。

基本语法

ini 复制代码

const index = array.indexOf(searchElement, fromIndex);

searchElement: 要在数组中查找的元素。
fromIndex（可选）: 开始查找的位置的索引。如果省略，搜索将从数组的开头（索引0）开始。

查找元素的索引

ini 复制代码

const array = [1, 2, 3, 4, 5];
const index = array.indexOf(3);
console.log(index); // 输出: 2

在这个示例中，indexOf() 方法被用来查找数字 3 在数组中的索引。由于 3 存在于数组中，方法返回其索引 2。

查找不存在的元素

ini 复制代码

const array = [1, 2, 3, 4, 5];
const index = array.indexOf(6);
console.log(index); // 输出: -1

这个示例查找数字 6 在数组中的索引。由于 6 不在数组中，方法返回 -1。

指定从特定索引开始搜索

ini 复制代码

const array = [1, 2, 3, 4, 3, 5];
const index = array.indexOf(3, 3);
console.log(index); // 输出: 4

在这个示例中，indexOf() 方法从索引 3 开始搜索数字 3。由于数组中索引 3 之后的第一个 3 出现在索引 4，方法返回 4。

需要注意的是

indexOf() 方法使用严格相等（===）来判断元素是否相等，这意味着比较时不会进行类型转换。
如果 fromIndex 大于或等于数组长度，返回 -1，因为数组不会被搜索。
如果 fromIndex 是负数，它将被当作从数组末尾向前的偏移量。如果计算后的索引仍小于0，则整个数组会被搜索。

`lastIndexOf()`

lastIndexOf() 方法用于搜索数组中的元素，并返回该元素在数组中最后一次出现的索引。如果没有找到元素，则返回 -1。

基本语法

ini 复制代码

const index = array.lastIndexOf(searchElement, fromIndex);

earchElement: 要在数组中查找的元素。
fromIndex（可选）: 开始查找的位置的索引。如果省略，搜索将从数组的末尾开始。如果提供，搜索将从该索引开始向前搜索。

查找元素的最后一个索引

ini 复制代码

const array = [1, 2, 3, 4, 3, 5];
const index = array.lastIndexOf(3);
console.log(index); // 输出: 4

在这个示例中，lastIndexOf() 方法被用来查找数字 3 在数组中的最后一个索引。由于 3 最后一次出现在索引 4，方法返回 4。

查找不存在的元素

ini 复制代码

const array = [1, 2, 3, 4, 5];
const index = array.lastIndexOf(6);
console.log(index); // 输出: -1

这个示例查找数字 6 在数组中的索引。由于 6 不在数组中，方法返回 -1。

指定从特定索引开始向前搜索

ini 复制代码

const array = [1, 2, 3, 4, 3, 5];
const index = array.lastIndexOf(3, 3);
console.log(index); // 输出: 2

在这个示例中，lastIndexOf() 方法从索引 3 开始向前搜索数字 3。由于数组中索引 3 之前的第一个 3 出现在索引 2，方法返回 2。

需要注意的是

lastIndexOf() 方法使用严格相等（===）来判断元素是否相等，这意味着比较时不会进行类型转换。
如果 fromIndex 大于或等于数组长度，搜索将从数组末尾开始。
如果 fromIndex 是负数，它将被当作从数组末尾向前的偏移量。如果计算后的索引仍小于0，则不会进行搜索，直接返回 -1。

`includes()`

includes() 方法用于检查数组中是否包含指定的元素。如果找到至少一个元素满足条件，返回 true；否则返回 false。

基本语法

ini 复制代码

const result = array.includes(searchElement, fromIndex);

searchElement: 要在数组中查找的元素。
fromIndex（可选）: 开始查找的位置的索引。如果省略或其值为0，搜索将从数组的开头开始。如果是负值，则表示从数组末尾向前的偏移量。

检查数组中是否包含特定元素

ini 复制代码

const array = [1, 2, 3, 4, 5];
const includesThree = array.includes(3);
console.log(includesThree); // 输出: true

在这个示例中，includes() 方法被用来检查数组中是否包含数字 3。由于 3 存在于数组中，方法返回 true。

检查数组中是否包含不存在的元素

ini 复制代码

const array = [1, 2, 3, 4, 5];
const includesSix = array.includes(6);
console.log(includesSix); // 输出: false

这个示例检查数组中是否包含数字 6。由于 6 不在数组中，方法返回 false。

从特定索引开始检查

ini 复制代码

const array = [1, 2, 3, 4, 5];
const includesThree = array.includes(3, 3);
console.log(includesThree); // 输出: false

在这个示例中，尽管数字 3 存在于数组中，但是 includes() 方法从索引 3 开始搜索，而在这个起始点之后没有数字 3，因此返回 false。

需要注意的是

includes() 方法使用严格相等（===）来判断元素是否相等，这意味着比较时不会进行类型转换。
如果 fromIndex 是负数，它将被当作从数组末尾向前的偏移量。如果计算后的索引仍小于0，则整个数组会被搜索。
includes() 方法对NaN的处理与其他方法不同，它能正确判断NaN是否存在于数组中（indexOf() 不能正确判断NaN）。

5.其他方法：

`join()`

join() 方法用于将数组中的所有元素连接成一个字符串，并返回这个字符串。你可以指定一个字符串作为分隔符来分隔数组中的元素。如果没有提供分隔符，默认使用逗号（,）作为分隔符。

基本语法

ini 复制代码

const str = array.join(separator);

separator（可选）: 用作分隔符的字符串。如果省略，数组元素将被逗号分隔。如果分隔符是空字符串（''），则元素之间不会插入任何字符。

将数组元素连接成字符串

ini 复制代码

const array = ['Hello', 'world', 'JavaScript'];
const joinedString = array.join(' ');
console.log(joinedString); // 输出: 'Hello world JavaScript'

在这个示例中，join() 方法使用空格（' '）作为分隔符，将数组中的字符串元素连接成一个单一的字符串。

使用不同的分隔符

ini 复制代码

const array = [1, 2, 3, 4, 5];
const joinedString = array.join('-');
console.log(joinedString); // 输出: '1-2-3-4-5'

这个示例展示了如何使用破折号（'-'）作为分隔符来连接数组元素。

不使用分隔符

ini 复制代码

const array = ['2023', '04', '10'];
const joinedString = array.join('');
console.log(joinedString); // 输出: '20230410'

在这个示例中，join() 方法使用空字符串作为分隔符，因此数组元素被直接连接在一起，没有任何分隔符。

需要注意的是

join() 方法不会修改原数组，而是返回一个新的字符串。
如果数组中的任何元素是undefined或null，它们会被转换为空字符串。
join() 方法非常适用于需要将数组元素格式化输出为字符串的场景，如生成文件路径、URL参数串联等。

`toString()`

toString() 方法用于将数组转换成一个字符串表示，并返回这个字符串。这个方法将数组中的每个元素转换为字符串，如果元素是null或undefined，它们会被转换成空字符串，然后将这些字符串用逗号（,）连接起来。

基本语法

ini 复制代码

const stringRepresentation = array.toString();

此方法不接受任何参数。

将数组转换为字符串

ini 复制代码

const array = [1, 'apple', null, undefined, true];
const result = array.toString();
console.log(result); // 输出: "1,apple,,,true"

在这个示例中，数组包含多种类型的元素，包括数字、字符串、null、undefined和布尔值。toString() 方法将每个元素转换为字符串，并用逗号连接它们。注意，null和undefined被转换成空字符串。

数组中包含数组的情况

ini 复制代码

const array = [1, 2, [3, 4], [5, 6]];
const result = array.toString();
console.log(result); // 输出: "1,2,3,4,5,6"

在这个示例中，数组中包含其他数组。toString() 方法递归地将所有数组元素扁平化并转换为一个逗号分隔的字符串。

需要注意的是

toString() 方法不会修改原数组。
toString() 方法实际上是调用每个元素的 toString() 方法来实现的，因此元素如何转换成字符串取决于元素类型的 toString() 实现。
对于空数组，toString() 返回空字符串。

`reduce()`

reduce() 方法用于对数组的每个元素执行一个由你提供的reducer函数（累加器），将其结果汇总为单个返回值。

基本语法

c 复制代码

const result = array.reduce(function(accumulator, currentValue, currentIndex, array) {
  // 返回结果将被用作下一次调用的accumulator
  return newAccumulatorValue;
}, initialValue);

accumulator: 累加器累计回调的返回值；它是上一次调用回调时返回的累积值，或者是提供的初始值（initialValue）。
currentValue: 数组中正在处理的元素。
currentIndex（可选）: 数组中正在处理的当前元素的索引。
array（可选）: 调用reduce的数组。
initialValue（可选）: 传递给函数的第一次调用的初始值。

累加数组中的所有值

ini 复制代码

const array = [1, 2, 3, 4];
const sum = array.reduce(function(accumulator, currentValue) {
  return accumulator + currentValue;
}, 0);
console.log(sum); // 输出: 10

在这个示例中，reduce() 方法被用来计算数组中所有数字的总和。初始值为0，这是累加的起始值。

将数组中的元素连接成字符串

c 复制代码

const array = ['Fire', 'Air', 'Water'];
const combined = array.reduce(function(accumulator, currentValue) {
  return accumulator + ' ' + currentValue;
}, 'Elements:');
console.log(combined); // 输出: 'Elements: Fire Air Water'

这个示例展示了如何使用reduce()方法将数组中的字符串元素连接成一个单一的字符串，起始值为"Elements:"。

查找数组中的最大值

c 复制代码

const array = [5, 1, 8, 3];
const max = array.reduce(function(accumulator, currentValue) {
  return Math.max(accumulator, currentValue);
}, array[0]); // 初始值为数组的第一个元素
console.log(max); // 输出: 8

这个示例使用reduce()方法来找出数组中的最大值。

需要注意的是

如果没有提供initialValue，reduce()会从数组的第一个元素开始执行累加器函数，第一个元素会自动成为初始值。
如果数组为空且没有提供initialValue，将抛出TypeError。
reduce()方法不会改变原数组。

`reduceRight()`

reduceRight() 方法与 reduce() 方法类似，但它从数组的末尾开始向前应用一个函数，将数组元素累积为单个返回值。这种方法特别适用于处理需要从右向左处理的操作，如在某些累积或链式计算中。

基本语法

c 复制代码

const result = array.reduceRight(function(accumulator, currentValue, currentIndex, array) {
  // 返回结果将被用作下一次调用的accumulator
  return newAccumulatorValue;
}, initialValue);

accumulator: 累加器累计回调的返回值；它是上一次调用回调时返回的累积值，或者是提供的初始值（initialValue）。
currentValue: 数组中正在处理的元素。
currentIndex（可选）: 数组中正在处理的当前元素的索引。
array（可选）: 调用reduceRight的数组。
initialValue（可选）: 传递给函数的第一次调用的初始值。

累加数组中的所有值（从右向左）

ini 复制代码

const array = [1, 2, 3, 4];
const sum = array.reduceRight(function(accumulator, currentValue) {
  return accumulator + currentValue;
}, 0);
console.log(sum); // 输出: 10

在这个示例中，reduceRight() 方法被用来计算数组中所有数字的总和，从数组的末尾开始累加。

将数组中的字符串从右向左连接

javascript 复制代码

const array = ['end', 'to', 'start', 'from'];
const sentence = array.reduceRight(function(accumulator, currentValue) {
  return accumulator + ' ' + currentValue;
}, '');
console.log(sentence); // 输出: 'from start to end'

这个示例展示了如何使用reduceRight()方法将数组中的字符串元素从右向左连接成一个单一的字符串。

使用reduceRight处理嵌套数组

lua 复制代码

const array = [[0, 1], [2, 3], [4, 5]];
const flat = array.reduceRight(function(accumulator, currentValue) {
  return accumulator.concat(currentValue);
}, []);
console.log(flat); // 输出: [4, 5, 2, 3, 0, 1]

这个示例使用reduceRight()方法来压平一个数组，从数组的末尾开始处理，展示了如何将嵌套数组合并成一个单一数组。

需要注意的是

如果没有提供initialValue，reduceRight()会从数组的最后一个元素开始执行累加器函数，最后一个元素会自动成为初始值。
如果数组为空且没有提供initialValue，将抛出TypeError。
reduceRight()方法不会改变原数组。

这些分类可以帮助我们更好地理解这些方法的用途和功能。需要根据具体的需求选择适合的方法来操作和处理数组。如果你有任何其他问题，请随时提问！

JS 数组常用方法及使用方式

1.修改原数组的方法：

push()

pop()

shift()

unshift()

splice()

reverse()

sort()

coyWithin()

2.返回新数组的方法：

concat()

slice()

map()

filter()

flat()

flatMap()

3.遍历数组的方法：

forEach()

some()

every()

find()

findIndex()

4.元素定位的方法：

indexOf()

lastIndexOf()

includes()

5.其他方法：

join()

toString()

reduce()

reduceRight()

`push()`

`pop()`

`shift()`

`unshift()`

`splice()`

`reverse()`

`sort()`

`concat()`

`slice()`

`map()`

`filter()`

`flat()`

`flatMap()`

`forEach()`

`some()`

`every()`

`find()`

`findIndex()`

`indexOf()`

`lastIndexOf()`

`includes()`

`join()`

`toString()`

`reduce()`

`reduceRight()`