---

数组有哪些原生方法？

JavaScript中数组有许多原生方法用于执行各种操作。这些方法可以分为以下几个类别：

1. 数组和字符串的转换方法：

   • toString()：将数组转换为由逗号分隔的字符串。
   • join()：将数组的所有元素连接成一个字符串，可以指定一个自定义的分隔符。

2. 元素操作的方法：

   • push()：向数组末尾添加一个或多个新元素，并返回新数组的长度。
   • pop()：移除数组的最后一个元素，并返回该元素的值。
   • unshift()：在数组开头添加一个或多个新元素，并返回新数组的长度。
   • shift()：移除数组的第一个元素，并返回该元素的值。

3. 元素位置操作的方法：

   • indexOf()：返回指定元素在数组中的第一个匹配位置的索引，如果找不到则返回 -1。
   • lastIndexOf()：返回指定元素在数组中最后一个匹配位置的索引，如果找不到则返回 -1。

4. 切片操作的方法：

   • slice()：从原数组中提取指定的元素创建一个新数组。
   • splice()：从原数组中删除、替换或插入元素，并返回被删除的元素组成的新数组。

5. 遍历方法：

   • forEach()：对数组的每个元素执行指定的操作。
   • map()：创建一个由原数组每个元素执行回调函数的结果组成的新数组。

上述方法提供了便捷的方式来操作和处理数组中的元素，使得我们可以添加、删除、获取和修改数组中的值。需要注意的是，使用这些方法时，有些方法会修改原始数组，而有些会返回新的数组。

参考案例

接下来，我将对上述方法进行案例代码的描述，并展示这些方法的运行结果。

案例1：使用toString()和join()方法将数组转换为字符串

描述：我们有一个数组，想将它转换为字符串并打印出来。我们将使用toString()和join()方法进行转换。

var arr = [1, 2, 3, 4, 5]
var arrString = arr.toString()
var arrJoined = arr.join('-')console.log(arrString) // 输出： "1,2,3,4,5"
console.log(arrJoined) // 输出： "1-2-3-4-5"

运行结果：

"1,2,3,4,5"
"1-2-3-4-5"

案例2：使用push()和pop()方法添加和删除数组元素

描述：我们有一个数组，并希望使用push()方法在数组末尾添加元素，然后使用pop()方法从数组末尾删除元素。

var arr = [1, 2, 3]
arr.push(4)
var poppedElement = arr.pop()console.log(arr) // 输出：[1, 2, 3]
console.log(poppedElement) // 输出：4

运行结果：

[1, 2, 3]
4

案例3：使用indexOf()和lastIndexOf()方法获取元素位置

描述：我们有一个数组，并想要获取特定元素的索引。我们将使用indexOf()方法查找第一个匹配项的索引，使用lastIndexOf()方法查找最后一个匹配项的索引。

var arr = [1, 2, 3, 2, 4]
var firstIndex = arr.indexOf(2)
var lastIndex = arr.lastIndexOf(2)console.log(firstIndex) // 输出：1
console.log(lastIndex) // 输出：3

运行结果：

1
3

案例4：使用slice()和splice()方法进行切片操作

描述：我们有一个数组，并希望通过切片操作创建一个新的子数组。我们将使用slice()方法和splice()方法来实现。

var arr = [1, 2, 3, 4, 5]
var slicedArr = arr.slice(1, 4)
var splicedArr = arr.splice(2, 2, 6, 7)console.log(slicedArr) // 输出：[2, 3, 4]
console.log(splicedArr) // 输出：[3, 4]
console.log(arr) // 输出：[1, 2, 6, 7, 5]

运行结果：

[2, 3, 4]
[3, 4]
[1, 2, 6, 7, 5]

常见的位运算符有哪些？

JavaScript中常见的位运算符有以下几种：

1. 按位与（&）
2. 按位或（|）
3. 按位异或（^）
4. 按位取反（~）
5. 左移（<<）
6. 右移（>>）
7. 无符号右移（>>>）

这些位运算符是用来对二进制数进行操作的，它们对二进制数中的每一位进行操作，因此被称为“位运算符”。

以下是每种位运算符的计算规则：

1. 按位与（&）：将两个数的二进制数按位进行与运算，得到的结果是一个新的二进制数，其中每一位都是两个二进制数对应位上的值相与的结果。例如，对于二进制数1010和1100进行按位与运算，结果为1000。

2. 按位或（|）：将两个数的二进制数按位进行或运算，得到的结果是一个新的二进制数，其中每一位都是两个二进制数对应位上的值相或的结果。例如，对于二进制数1010和1100进行按位或运算，结果为1110。

3. 按位异或（^）：将两个数的二进制数按位进行异或运算，得到的结果是一个新的二进制数，其中每一位都是两个二进制数对应位上的值相异或的结果。例如，对于二进制数1010和1100进行按位异或运算，结果为0110。

4. 按位取反（~）：将一个数的二进制数按位取反，得到的结果是一个新的二进制数，其中每一位都是原二进制数对应位上的值取反的结果。例如，对于二进制数1010进行按位取反运算，结果为0101。

5. 左移（<<）：将一个数的二进制数向左移动指定的位数，得到的结果是一个新的二进制数，其中低位补0。例如，对于二进制数1010进行左移两位运算，结果为101000。

6. 右移（>>）：将一个数的二进制数向右移动指定的位数，得到的结果是一个新的二进制数，其中高位补符号位。例如，对于二进制数1010进行右移两位运算，结果为000010。

7. 无符号右移（>>>）：将一个数的二进制数向右移动指定的位数，得到的结果是一个新的二进制数，其中高位补0。例如，对于二进制数1010进行无符号右移两位运算，结果为000010。

以下是一些位运算符的示例代码：

// 按位与（&）
const a = 10 // 二进制数为 1010
const b = 12 // 二进制数为 1100
const c = a & b // c的值为8，二进制数为 1000
console.log(c)// 按位或（|)
const d = a | b // d的值为14，二进制数为 1110
console.log(d)// 按位异或（^）
const e = a ^ b // e的值为6，二进制数为 0110
console.log(e)// 按位取反（~）
const f = ~a // f的值为-11，因为~a的结果是一个32位的有符号整数，需要使用补码表示
console.log(f)// 左移（<<）
const g = a << 2 // g的值为40，二进制数为 101000
console.log(g)// 右移（>>）
const h = b >> 2 // h的值为3，二进制数为 0011
console.log(h)// 无符号右移（>>>）
const i = b >>> 2 // i的值为3，二进制数为 0011
console.log(i)

总结

位运算符是用来对二进制数进行操作的，它们对二进制数中的每一位进行操作。常见的位运算符有按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）、右移（>>）和无符号右移（>>>）。每种位运算符都有自己的计算规则，可以通过对二进制数进行按位运算得到新的二进制数。在JavaScript中，位运算符可以通过使用二进制字面量或使用parseInt()函数将字符串转换为二进制数来操作二进制数。

为什么函数的 arguments 参数是类数组而不是数组？如何遍历类数组?

函数的 arguments 参数是类数组而不是数组，是因为 arguments 对象是在函数内部自动创建的，它包含了传递给函数的所有参数，无论这些参数是否被定义在函数的参数列表中。由于参数个数是不确定的，因此 arguments 对象被设计成类数组，可以通过下标来访问每个参数。

类数组对象是一种类似于数组的对象，它们具有类似于数组的下标和 length 属性，但是没有数组的原型方法。由于类数组对象不是真正的数组，因此不能使用数组的方法和属性，例如 push、pop、forEach 等。但是，可以使用 for 循环、while 循环和 Array.from 方法来遍历类数组对象。

以下是一个遍历 arguments 对象的示例代码：

function sum() {let result = 0for (let i = 0; i < arguments.length; i++) {result += arguments[i]}return result
}console.log(sum(1, 2, 3, 4, 5)) // 输出 15

在这个示例代码中，sum 函数使用 for 循环遍历 arguments 对象，将每个参数的值加起来，最后返回结果。由于 arguments 对象是类数组对象，因此可以通过下标访问每个参数的值。

总结：

arguments 参数是类数组而不是数组，是因为它包含了传递给函数的所有参数，无论这些参数是否被定义在函数的参数列表中，而参数个数是不确定的。类数组对象是一种类似于数组的对象，它们具有类似于数组的下标和 length 属性，但是没有数组的原型方法。遍历类数组对象可以使用 for 循环、while 循环和 Array.from 方法。

持续学习总结记录中，回顾一下上面的内容：
JavaScript 数组有许多原生方法，包括 push()、pop()、shift()、unshift()、splice()、slice()、concat()、join()、reverse()、sort()、indexOf()、lastIndexOf()、forEach()、map()、filter()、reduce()、some()、every() 等等。

常见的位运算符有 &、|、^、~、<<、>>、>>> 等，它们用于对数字的二进制位进行操作。

函数的 arguments 参数是类数组而不是数组，是因为 arguments 对象需要具有数组的下标访问和 length 属性等特性，但又不能是真正的数组对象，以避免出现一些不必要的问题。

遍历类数组对象可以使用 for 循环或 Array.prototype.forEach() 方法，也可以将类数组对象转换为真正的数组后使用数组的遍历方法。