JavaScript编码之路 【JavaScript之操作数组、字符串方法汇总】

如下是对 JavaScript 操作数组和字符串的方法的汇总

数组

数组的常用方法

操作方法

数组基本操作可以归纳为增、删、改、查，需要留意的是哪些方法会对原数组产生影响，哪些方法不会

下面是对数组常用的操作方法做一个归纳

增

下面前三种是对原数组产生影响的增添方法，第四种则不会对原数组产生影响

• push()
• unshift()
• splice()
• concat()

push()

push()方法接收任意数量的参数，并将它们添加到数组末尾，返回数组的最新长度

let colors = [] // 创建一个数组
let count = colors.push("res", "green") // 推入两项
console.log(count) // 2

unshift()

unshift()在数组开头添加任意多个值，然后返回新的数组长度

let colors = new Array() // 创建一个数组
let count = colors.unshift("red", "green") // 从数组开头推入两项
alert(count) // 2

splice()

splice() 是 JavaScript 数组的一个原生方法，用于在数组中插入、删除或替换元素。这个方法可以接收多个参数，其中前两个参数是必需的。

🗨️第一个参数，要操作的起始位置，也就是从哪个下标开始进行插入、删除或替换。

🗨️第二个参数，要删除的元素数量，如果为 0，则表示不删除任何元素，只进行插入操作。

🗨️第三个参数及以后，要插入到数组中的新元素，可以插入任意数量的元素。

删除元素

如果想从数组中删除元素，可以将第二个参数设为要删除的元素数量，而后面不传其他的插入元素：

const arr = [1, 2, 3, 4, 5];
arr.splice(2, 2); // 从下标为 2 的位置开始，删除两个元素
console.log(arr); // 输出：[1, 2, 5]

splice(2, 2) 表示从下标为 2 的位置开始，删除 2 个元素（即删除下标为 2 和 3 的元素），最终数组变成了 [1, 2, 5]。

插入元素

如果想向数组中插入新的元素，可以将第二个参数设为 0，然后在后面传入要插入的元素：

const arr = [1, 2, 3, 4, 5];
arr.splice(2, 0, 'a', 'b', 'c'); // 从下标为 2 的位置开始，插入三个元素
console.log(arr); // 输出：[1, 2, "a", "b", "c", 3, 4, 5]

splice(2, 0, ‘a’, ‘b’, ‘c’) 表示从下标为 2 的位置开始，删除 0 个元素，并插入三个元素（即插入 ‘a’、‘b’ 和 ‘c’），最终数组变成了 [1, 2, “a”, “b”, “c”, 3, 4, 5]。

替换元素

如果想替换数组中的某个元素，可以将第二个参数设为 1，并在后面传入要替换的新元素：

const arr = [1, 2, 3, 4, 5];
arr.splice(2, 1, 'a', 'b'); // 从下标为 2 的位置开始，删除一个元素，插入两个新元素
console.log(arr); // 输出：[1, 2, "a", "b", 4, 5]

splice(2, 1, ‘a’, ‘b’) 表示从下标为 2 的位置开始，删除 1 个元素（也就是删除下标为 2 的元素 3），并插入两个新元素 ‘a’ 和 ‘b’，最终数组变成了 [1, 2, “a”, “b”, 4, 5]。

concat()

concat()方法是JavaScript数组的一个内置方法，用于合并两个或多个数组。当调用concat()方法时，它会创建原始数组的一个副本，并将指定的参数数组连接到副本的末尾。这样做不会改变原始数组，而是返回一个新的合并后的数组。

我们来检验一下它的语法

const array1 = [1, 2, 3];
const array2 = [4, 5, 6];
const newArray = array1.concat(array2);

console.log(newArray); // 输出: [1, 2, 3, 4, 5, 6]
console.log(array1); // 输出: [1, 2, 3]，原始数组没有改变
console.log(array2); // 输出: [4, 5, 6]，原始数组没有改变

如上所示，通过调用concat()方法，我们创建了一个新数组newArray，它包含了array1和array2的合并结果。原始数组array1和array2保持不变。

当使用concat()方法时，可以传递一个或多个数组作为参数

// 合并两个数组
const array1 = [1, 2, 3];
const array2 = [4, 5, 6];
const newArray = array1.concat(array2);
console.log(newArray); // 输出: [1, 2, 3, 4, 5, 6]

// 合并三个数组
const array3 = [7, 8, 9];
const newArray2 = array1.concat(array2, array3);
console.log(newArray2); // 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

// 合并空数组
const emptyArray = [];
const newArray3 = array1.concat(emptyArray);
console.log(newArray3); // 输出: [1, 2, 3]

// 合并字符串和数组
const array4 = ['a', 'b', 'c'];
const newArray4 = array1.concat(array4, 'd');
console.log(newArray4); // 输出: [1, 2, 3, 'a', 'b', 'c', 'd']

我们使用了concat()方法将多个数组合并成一个新数组。注意，传递给concat()方法的参数可以是数组，也可以是其他类型的值。在最后，我们将字符串和数组一起传递给concat()方法，新数组中包含了原始数组的元素以及额外的字符串。

咱继续看一个复杂的

const array1 = [1, 2, 3];
const array2 = [4, 5, 6];
const array3 = [7, 8, 9];

const nestedArray = [array1, array2];

const newArray = array1.concat(array2, array3, ['a', 'b'], ...nestedArray);
console.log(newArray);
// 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', [1, 2, 3], [4, 5, 6]]

咱们定义了三个数组array1、array2和array3。然后，咱们创建了一个嵌套数组nestedArray，它包含了array1和array2作为元素。

接下来，咱们使用concat()方法将多个数组合并成一个新数组。除了传递array1、array2和array3之外，咱们还传递了一个包含字符串数组[‘a’, ‘b’]，以及使用扩展运算符(…)展开的nestedArray。

最终，新数组newArray包含了原始数组的所有元素，以及额外的字符串和嵌套数组。注意，嵌套数组没有展开，而是保留了原始的形式。

删

下面前三种都会影响原数组，最后一项不影响原数组:

• pop()
• shift()
• splice()
• slice()

pop()

pop()方法用于删除数组的最后一项，同时减少数组的length值，返回被删除的项

const array1 = [1, 2, 3];
const lastItem = array1.pop(); // 删除最后一项，并返回被删除的项

console.log(lastItem); // 输出: 3
console.log(array1); // 输出: [1, 2]

如上所示，咱们定义了一个数组array1，并调用pop()方法来删除最后一项。pop()方法返回被删除的项3，原始数组变成了[1, 2]。

需要注意的是，pop()方法不仅会删除最后一项，还会更改数组的长度值。同时，当原始数组为空数组时，调用pop()方法将返回undefined，并且不会更改数组的长度。

shift()

shift()方法是JavaScript数组的另一个内置方法，它用于从数组的开头删除第一项，并返回被删除的项。

const array1 = [1, 2, 3];
const firstItem = array1.shift(); // 删除第一项，并返回被删除的项

console.log(firstItem); // 输出: 1
console.log(array1); // 输出: [2, 3]

如上定义了一个数组array1，并调用shift()方法来删除第一项。shift()方法返回被删除的项1，原始数组变成了[2, 3]。

需要注意的是，shift()方法不仅会删除第一项，还会更改数组的长度值。同时，当原始数组为空数组时，调用shift()方法将返回undefined，并且不会更改数组的长度。

splice()

前面我们已经讲过其删的用法了，这里简单描述一下：传入两个参数，分别是开始位置，删除元素的数量，返回包含删除元素的数组

let colors = ["red", "green", "blue"]
let removed = colors.splice(0, 1) // 删除第一项
console.log(colors) // green, blue
console.log(remove) // red，只有一个元素的数组

slice()

slice()方法是JavaScript数组的一个内置方法，用于创建一个包含原有数组中一个或多个元素的新数组，而不会影响原始数组。

const array1 = [1, 2, 3, 4, 5];
const newArray = array1.slice(1, 4);

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

如上代码，我们定义了一个数组array1。然后，我们调用slice()方法，并传入索引参数1和4，这表示我们想要提取从索引1（包括）到索引4（不包括）之间的元素。

slice()方法返回一个新数组newArray，其中包含了原始数组中指定索引范围内的元素[2, 3, 4]。原始数组array1保持不变，仍然是[1, 2, 3, 4, 5]。

我们可以看到，slice()方法不会修改原始数组，并且可以接受两个可选的参数，用于指定开始和结束提取的索引位置。

注意：如果只传入一个参数，则提取从该索引开始到数组末尾的所有元素。如果未传入任何参数，则提取整个数组的副本。

最后，我们来看看slice的妙用

1. 复制一个数组

我们使用slice()方法而没有传入任何参数，从而创建了原始数组originalArray的一个副本copiedArray。

const originalArray = [1, 2, 3, 4, 5];
const copiedArray = originalArray.slice();
console.log(copiedArray)