数组方法

改变数组的方法

1.push()方法

push() 方法是 JavaScript 中数组对象的一个原生方法，用于向数组的末尾添加一个或多个元素。以下是它的语法：

let fruits = ['apple', 'banana']; // 原始数组
console.log(fruits.length); // 打印原始数组的长度

fruits.push('orange'); // 向数组末尾添加一个元素
console.log(fruits); // 打印添加后的新数组

fruits.push('kiwi', 'pear'); // 向数组末尾添加多个元素
console.log(fruits); // 打印添加后的新数组

console.log(fruits.length); // 打印新数组的长度

结果： 

2
[ 'apple', 'banana', 'orange' ]
[ 'apple', 'banana', 'orange', 'kiwi', 'pear' ]
5

2.pop()方法

‘pop() 方法是 JavaScript 中数组对象的一个原生方法，用于从数组的末尾删除最后一个元素，并返回该元素的值。以下是它的语法：

let fruits = ['apple', 'banana', 'orange']; // 原始数组
console.log(fruits); // 打印原始数组

let lastFruit = fruits.pop(); // 从数组末尾删除最后一个元素
console.log(lastFruit); // 打印删除的元素

console.log(fruits); // 打印新数组

结果：

[ 'apple', 'banana', 'orange' ]
orange
[ 'apple', 'banana' ]

3.shift()方法

shift() 方法是 JavaScript 数组的一个方法，用于删除数组的第一个元素，并返回被删除的元素。

下面是一个 shift() 方法的示例：

let fruits = ['apple', 'banana', 'orange'];

let shiftedElement = fruits.shift();

console.log(shiftedElement); // 输出: 'apple'
console.log(fruits); // 输出: ['banana', 'orange']

4.unshift()方法

unshift() 方法是 JavaScript 数组的一个方法，用于在数组的开头添加一个或多个元素，并返回新的数组长度。

下面是一个 unshift() 方法的示例：

let fruits = ['banana', 'orange'];

let newLength = fruits.unshift('apple', 'grape');

console.log(newLength); // 输出: 4
console.log(fruits); // 输出: ['apple', 'grape', 'banana', 'orange']

5.reverse() 方法

reverse() 方法是 JavaScript 数组的一个方法，用于颠倒数组中元素的顺序，并返回更新后的数组。

下面是一个 reverse() 方法的示例：

let arr = ['apple', 'banana', 'orange'];

arr.reverse();

console.log(arr); // 输出: ['orange', 'banana', 'apple']

6.sort() 方法

sort() 方法是 JavaScript 数组的一个方法，用于对数组元素进行排序，并返回更新后的数组。

下面是一个 sort() 方法的示例：

let arr = ['orange', 'banana', 'apple'];

arr.sort();

console.log(arr); // 输出: ['apple', 'banana', 'orange']

7.splice()方法

splice() 方法是 JavaScript 数组的一个方法，用于从数组中删除、替换或插入元素，并返回被删除的元素。

下面是一些 splice() 方法的示例：

1. 删除元素：

   let arr = ['apple', 'banana', 'orange'];
   arr.splice(1, 1); // 从索引位置 1 开始删除一个元素
   console.log(arr); // 输出: ['apple', 'orange']
   

   在上面的示例中，我们有一个名为 arr 的数组，包含三个元素：'apple'、'banana' 和 'orange'。通过调用 splice() 方法并传入参数 1 和 1，我们从索引位置 1 开始删除了一个元素。最后，我们打印出更新后的 arr 数组。

2. 替换元素：

   let arr = ['apple', 'banana', 'orange'];
   arr.splice(1, 1, 'grape'); // 从索引位置 1 开始删除一个元素，并在该位置插入 'grape'
   console.log(arr); // 输出: ['apple', 'grape', 'orange']
   

   在上面的示例中，我们有一个名为 arr 的数组，包含三个元素：'apple'、'banana' 和 'orange'。通过调用 splice() 方法并传入参数 1、1 和 'grape'，我们从索引位置 1 开始删除了一个元素，并在该位置插入了新元素 'grape'。最后，我们打印出更新后的 arr 数组。

3. 插入元素：

   let arr = ['apple', 'banana', 'orange'];
   arr.splice(2, 0, 'grape'); // 在索引位置 2 插入 'grape'，不删除任何元素
   console.log(arr); // 输出: ['apple', 'banana', 'grape', 'orange']
   

   在上面的示例中，我们有一个名为 arr 的数组，包含三个元素：'apple'、'banana' 和 'orange'。通过调用 splice() 方法并传入参数 2、0 和 'grape'，我们在索引位置 2 插入了新元素 'grape'，并且没有删除任何元素。最后，我们打印出更新后的 arr 数组。

不变更原数组的方法

8.concat()方法

concat() 方法是 JavaScript 数组的一个方法，用于将多个数组或值合并成一个新数组，并返回该新数组。

下面是一些 concat() 方法的示例：

1. 合并数组：

   let arr1 = ['apple', 'banana'];
   let arr2 = ['orange', 'grape'];
   let newArr = arr1.concat(arr2);
   console.log(newArr); // 输出: ['apple', 'banana', 'orange', 'grape']
   

   在上面的示例中，我们有两个数组 arr1 和 arr2，分别包含两个元素。通过调用 concat() 方法将这两个数组合并成一个新数组 newArr，我们得到了一个包含所有元素的新数组。最后，我们打印出新数组 newArr。

2. 合并值和数组：

   let arr = ['apple', 'banana'];
   let newArr = arr.concat('orange', ['grape']);
   console.log(newArr); // 输出: ['apple', 'banana', 'orange', 'grape']
   

   在上面的示例中，我们有一个数组 arr，包含两个元素。通过调用 concat() 方法并传入字符串 'orange' 和数组 ['grape']，我们将这些值和数组合并成一个新数组 newArr。最后，我们打印出新数组 newArr。

3. 合并多个数组：

   let arr1 = ['apple'];
   let arr2 = ['banana'];
   let arr3 = ['orange'];
   let newArr = arr1.concat(arr2, arr3);
   console.log(newArr); // 输出: ['apple', 'banana', 'orange']
   

   在上面的示例中，我们有三个数组 arr1、arr2 和 arr3，每个数组只包含一个元素。通过调用 concat() 方法并传入这三个数组，我们将它们合并成一个新数组 newArr。最后，我们打印出新数组 newArr。

9.join()方法

join() 方法是 JavaScript 数组的一个方法，用于将数组中的所有元素转换为一个字符串，并使用指定的分隔符进行连接。

下面是一些 join() 方法的示例：

1. 使用默认分隔符：

   let arr = ['apple', 'banana', 'orange'];
   let str = arr.join();
   console.log(str); // 输出: "apple,banana,orange"
   

   在上面的示例中，我们有一个名为 arr 的数组，包含三个元素：'apple'、'banana' 和 'orange'。通过调用 join() 方法，它会将数组中的所有元素转换为一个字符串，并使用默认的逗号分隔符连接它们。最后，我们打印出连接后的字符串 str。

2. 使用自定义分隔符

   let arr = ['apple', 'banana', 'orange'];
   let str = arr.join('-');
   console.log(str); // 输出: "apple-banana-orange"
   

   在上面的示例中，我们有一个名为 arr 的数组，包含三个元素：'apple'、'banana' 和 'orange'。通过调用 join('-') 方法，它会将数组中的所有元素转换为一个字符串，并使用自定义的连字符分隔符连接它们。最后，我们打印出连接后的字符串 str。

3. 连接数字数组：

   let arr = [1, 2, 3];
   let str = arr.join('');
   console.log(str); // 输出: "123"
   

   在上面的示例中，我们有一个名为 arr 的数组，包含三个元素：1、2 和 3。通过调用 join('') 方法，它会将数组中的所有元素转换为一个字符串，并使用空字符串作为分隔符连接它们。由于数组中的元素都是数字，它们会被转换为字符串并连接在一起。最后，我们打印出连接后的字符串 str。

10.slice() 方法

slice() 方法是 JavaScript 字符串和数组的一个方法，用于从原始字符串或数组中提取出指定部分，并返回一个新的字符串或数组，而不会修改原始字符串或数组。

下面是一些 slice() 方法的示例：

1. 提取字符串的一部分：

   let str = "Hello, World!";
   let newStr = str.slice(7, 12);
   console.log(newStr); // 输出: "World"
   

   在上面的示例中，我们有一个名为 str 的字符串。通过调用 slice(7, 12) 方法，它会从索引位置 7 开始提取字符串，并一直提取到索引位置 12（不包括该位置），得到一个新的字符串 newStr。最后，我们打印出提取出的新字符串 newStr。

2. 提取数组的一部分：

   let arr = [1, 2, 3, 4, 5];
   let newArr = arr.slice(2, 4);
   console.log(newArr); // 输出: [3, 4]
   

   在上面的示例中，我们有一个名为 arr 的数组。通过调用 slice(2, 4) 方法，它会从索引位置 2 开始提取数组，并一直提取到索引位置 4（不包括该位置），得到一个新的数组 newArr。最后，我们打印出提取出的新数组 newArr。

3. 不带参数的使用：

   let str = "Hello, World!";
   let newStr = str.slice();
   console.log(newStr); // 输出: "Hello, World!"
   

   在上面的示例中，我们有一个名为 str 的字符串。通过调用 slice() 方法而不传递任何参数，它会返回原始字符串的副本，即与原始字符串相同的新字符串 newStr。最后，我们打印出新字符串 newStr。

11.toString()

toString() 方法是 JavaScript 中的一个方法，用于将一个值转换为字符串。

下面是一些 toString() 方法的示例：

1. 转换数字为字符串：

   let num = 123;
   let str = num.toString();
   console.log(str); // 输出: "123"
   

   在上面的示例中，我们有一个名为 num 的数字。通过调用 toString() 方法，它会将数字转换为字符串，并赋值给变量 str。最后，我们打印出转换后的字符串 str。

2. 转换布尔值为字符串：

   let bool = true;
   let str = bool.toString();
   console.log(str); // 输出: "true"
   

   在上面的示例中，我们有一个名为 bool 的布尔值。通过调用 toString() 方法，它会将布尔值转换为字符串，并赋值给变量 str。最后，我们打印出转换后的字符串 str。

3. 转换数组为字符串：

   let arr = [1, 2, 3];
   let str = arr.toString();
   console.log(str); // 输出: "1,2,3"
   

   在上面的示例中，我们有一个名为 arr 的数组。通过调用 toString() 方法，它会将数组转换为字符串，并赋值给变量 str。最后，我们打印出转换后的字符串 str。

   需要注意的是，toString() 方法仅适用于基本数据类型（如数字、布尔值等）和一些内置对象（如数组）。对于自定义对象，可以通过重写对象的 toString() 方法来实现自定义的字符串转换逻辑。

12.indexOf() 方法

indexOf() 方法是 JavaScript 中的一个方法，用于在字符串或数组中查找指定元素的位置。如果找到该元素，则返回其在字符串或数组中的索引值；如果未找到，则返回 -1。

下面是一些 indexOf() 方法的示例：

1. 查找字符串中的子串：

   let str = "Hello, World!";
   let index = str.indexOf("World");
   console.log(index); // 输出: 7
   

   在上面的示例中，我们有一个名为 str 的字符串。通过调用 indexOf("World") 方法，它会在字符串中查找子串 "World" 并返回其在字符串中的索引值。最后，我们打印出子串在字符串中的索引值 index。

2. 查找数组中的元素：

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

   在上面的示例中，我们有一个名为 arr 的数组。通过调用 indexOf(3) 方法，它会在数组中查找元素 3 并返回其在数组中的索引值。最后，我们打印出元素在数组中的索引值 index。

3. 查找不存在的元素：

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

   在上面的示例中，我们有一个名为 arr 的数组。通过调用 indexOf(6) 方法，它会在数组中查找元素 6 并返回其在数组中的索引值。由于数组中不存在元素 6，因此 indexOf() 方法将返回 -1。

   需要注意的是，indexOf() 方法是区分大小写的。如果要进行不区分大小写的查找，则可以先将字符串或数组中的所有元素转换为小写或大写字母，然后再进行查找

13.lastIndexOf()方法

lastIndexOf() 方法是 JavaScript 中的一个方法，用于在字符串或数组中从后向前查找指定元素的位置。如果找到该元素，则返回其在字符串或数组中最后一次出现的索引值；如果未找到，则返回 -1。

下面是一些 lastIndexOf() 方法的示例：

1. 查找字符串中的子串：

   let str = "Hello, World!";
   let index = str.lastIndexOf("o");
   console.log(index); // 输出: 8
   

   在上面的示例中，我们有一个名为 str 的字符串。通过调用 lastIndexOf("o") 方法，它会在字符串中从后向前查找字符 "o" 并返回最后一次出现的索引值。最后，我们打印出字符在字符串中的索引值 index。

2. 查找数组中的元素：

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

   在上面的示例中，我们有一个名为 arr 的数组。通过调用 lastIndexOf(3) 方法，它会在数组中从后向前查找元素 3 并返回最后一次出现的索引值。最后，我们打印出元素在数组中的索引值 index。

3. 查找不存在的元素：

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

   在上面的示例中，我们有一个名为 arr 的数组。通过调用 lastIndexOf(6) 方法，它会在数组中从后向前查找元素 6 并返回最后一次出现的索引值。由于数组中不存在元素 6，因此 lastIndexOf() 方法将返回 -1。

   需要注意的是，lastIndexOf() 方法是区分大小写的。如果要进行不区分大小写的查找，则可以先将字符串或数组中的所有元素转换为小写或大写字母，然后再进行查找。

14.includes()方法示例

includes() 方法是 JavaScript 中的一个方法，用于检查字符串或数组是否包含指定的元素。如果包含该元素，则返回 true；否则返回 false。

下面是一些 includes() 方法的示例：

1. 检查字符串中是否包含子串：

   let str = "Hello, World!";
   let result = str.includes("World");
   console.log(result); // 输出: true
   

   在上面的示例中，我们有一个名为 str 的字符串。通过调用 includes("World") 方法，它会检查字符串中是否包含子串 "World"。由于字符串中包含该子串，因此 includes() 方法将返回 true。

2. 检查数组中是否包含元素：

   let arr = [1, 2, 3, 4, 5];
   let result = arr.includes(3);
   console.log(result); // 输出: true
   

   在上面的示例中，我们有一个名为 arr 的数组。通过调用 includes(3) 方法，它会检查数组中是否包含元素 3。由于数组中包含该元素，因此 includes() 方法将返回 true。

3. 检查不存在的元素：

   let arr = [1, 2, 3, 4, 5];
   let result = arr.includes(6);
   console.log(result); // 输出: false
   

   在上面的示例中，我们有一个名为 arr 的数组。通过调用 includes(6) 方法，它会检查数组中是否包含元素 6。由于数组中不存在该元素，因此 includes() 方法将返回 false。

   需要注意的是，includes() 方法也是区分大小写的。如果要进行不区分大小写的检查，则可以先将字符串或数组中的所有元素转换为小写或大写字母，然后再进行检查。

迭代方法

15.forEach() 方法

forEach() 方法用于遍历数组，并对数组中的每个元素执行指定的操作。以下是一个使用 forEach() 方法的示例：

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

array.forEach((element) => {
  console.log(element);
});

// 输出：
// 1
// 2
// 3
// 4
// 5

在上面的示例中，我们定义了一个名为 array 的数组，其中包含了一些数字。然后，我们使用 forEach() 方法遍历数组中的每个元素，并通过回调函数打印每个元素的值到控制台。

forEach() 方法的参数是一个回调函数，该回调函数接受三个参数：当前遍历的元素、当前元素的索引和正在遍历的数组。在示例中，我们只使用了第一个参数 element，即当前遍历的元素。

除了打印元素的值，你还可以在回调函数中执行其他操作，例如修改元素、计算总和等等。

需要注意的是，forEach() 方法没有返回值，它仅用于遍历数组。如果你需要创建一个新的数组或对数组中的每个元素进行转换，请考虑使用 map() 方法。

16.map()方法

map() 方法用于遍历数组，并对数组中的每个元素进行操作，然后返回一个新的数组。以下是一个使用 map() 方法的示例：

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

const newArray = array.map((element) => {
  return element * 2;
});

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

17.filter()方法

filter() 方法用于遍历数组，并根据指定条件筛选出满足条件的元素，然后返回一个新的数组。以下是一个使用 filter() 方法的示例：

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

const newArray = array.filter((element) => {
  return element % 2 === 0;
});

console.log(newArray);
// 输出：[2, 4]

在上面的示例中，我们定义了一个名为 array 的数组，其中包含了一些数字。然后，我们使用 filter() 方法遍历数组中的每个元素，并根据元素是否为偶数来进行筛选。

filter() 方法的参数是一个回调函数，该回调函数接受三个参数：当前遍历的元素、当前元素的索引和正在遍历的数组。在示例中，我们只使用了第一个参数 element，即当前遍历的元素。

回调函数中的 return 语句用于指定筛选条件。在示例中，我们使用取余运算符 % 来判断元素是否为偶数，如果是，则保留该元素。

18.reduce()

reduce() 方法用于遍历数组，并将数组中的元素合并成一个值，然后返回这个值。以下是一个使用 reduce() 方法的示例：

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

const sum = array.reduce((accumulator, currentValue) => {
  return accumulator + currentValue;
}, 0);

console.log(sum);
// 输出：15

在上面的示例中，我们定义了一个名为 array 的数组，其中包含了一些数字。然后，我们使用 reduce() 方法遍历数组中的每个元素，并将所有元素相加得到总和。

reduce() 方法的参数是一个回调函数和一个初始值。回调函数接受两个参数：累加器 accumulator 和当前元素 currentValue。初始值指定了累加器的初始值，可以是一个数字、字符串或任何类型的值。

在示例中，我们使用了初始值 0，将累加器的初始值设置为 0。回调函数中，我们将累加器 accumulator 和当前元素 currentValue 相加，并返回结果。

reduce() 方法会依次遍历数组的每个元素，并将每个元素与累加器进行操作，最终返回操作后的最终值。

19.reduceRight()

reduceRight() 方法与 reduce() 方法类似，不同之处在于它从数组的末尾开始遍历。以下是一个使用 reduceRight() 方法的示例：

const array = ["a", "b", "c", "d", "e"];

const result = array.reduceRight((accumulator, currentValue) => {
  return accumulator + currentValue;
});

console.log(result);
// 输出：'edcba'

在上面的示例中，我们定义了一个名为 array 的数组，其中包含了一些字符串。然后，我们使用 reduceRight() 方法遍历数组中的每个元素，并将所有元素合并成一个新的字符串。

reduceRight() 方法的参数和 reduce() 方法相同。回调函数接受两个参数：累加器 accumulator 和当前元素 currentValue。回调函数中，我们将当前元素 currentValue 添加到累加器 accumulator 的前面，并返回结果。

reduceRight() 方法会从数组的末尾开始遍历，依次对每个元素执行回调函数，并将每个元素与累加器进行操作，最终返回操作后的最终值。

20.every()方法

every() 方法用于检查数组中的每个元素是否都满足指定条件，如果都满足，则返回 true，否则返回 false。以下是一个使用 every() 方法的示例：

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

const result = array.every((element) => {
  return element > 0;
});

console.log(result);
// 输出：true

在上面的示例中，我们定义了一个名为 array 的数组，其中包含了一些数字。然后，我们使用 every() 方法遍历数组中的每个元素，并检查每个元素是否大于 0。

every() 方法的参数是一个回调函数，该回调函数接受三个参数：当前遍历的元素、当前元素的索引和正在遍历的数组。在示例中，我们只使用了第一个参数 element，即当前遍历的元素。

回调函数中的 return 语句用于指定条件判断。在示例中，我们判断每个元素是否大于 0，如果是，则返回 true。

every() 方法会依次遍历数组的每个元素，如果所有元素都满足指定条件，则返回 true；如果有任意一个元素不满足条件，则返回 false。

21.some()方法

some() 方法用于检查数组中是否存在至少一个元素满足指定条件，如果存在，则返回 true，否则返回 false。以下是一个使用 some() 方法的示例：

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

const result = array.some((element) => {
  return element > 3;
});

console.log(result);
// 输出：true

在上面的示例中，我们定义了一个名为 array 的数组，其中包含了一些数字。然后，我们使用 some() 方法遍历数组中的每个元素，并检查每个元素是否大于 3。

some() 方法的参数是一个回调函数，该回调函数接受三个参数：当前遍历的元素、当前元素的索引和正在遍历的数组。在示例中，我们只使用了第一个参数 element，即当前遍历的元素。

回调函数中的 return 语句用于指定条件判断。在示例中，我们判断每个元素是否大于 3，如果有任意一个元素大于 3，则返回 true。

some() 方法会依次遍历数组的每个元素，如果存在至少一个元素满足指定条件，则返回 true；如果所有元素都不满足条件，则返回 false

22.find()方法

find() 方法用于从数组中找到满足指定条件的第一个元素，并返回该元素。以下是一个使用 find() 方法的示例：

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

const result = array.find((element) => {
  return element > 3;
});

console.log(result);
// 输出：4

在上面的示例中，我们定义了一个名为 array 的数组，其中包含了一些数字。然后，我们使用 find() 方法遍历数组中的每个元素，并检查每个元素是否大于 3。

find() 方法的参数是一个回调函数，该回调函数接受三个参数：当前遍历的元素、当前元素的索引和正在遍历的数组。在示例中，我们只使用了第一个参数 element，即当前遍历的元素。

回调函数中的 return 语句用于指定条件判断。在示例中，我们判断每个元素是否大于 3，当找到第一个满足条件的元素时，就会返回该元素。

find() 方法会依次遍历数组的每个元素，如果找到满足条件的元素，则返回该元素；如果所有元素都不满足条件，则返回 undefined。

23.findIndex()

findIndex() 方法用于从数组中找到满足指定条件的第一个元素，并返回该元素的索引值。以下是一个使用 findIndex() 方法的示例：

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

const index = array.findIndex((element) => {
  return element > 3;
});

console.log(index);
// 输出：3

在上面的示例中，我们定义了一个名为 array 的数组，其中包含了一些数字。然后，我们使用 findIndex() 方法遍历数组中的每个元素，并检查每个元素是否大于 3。

findIndex() 方法的参数是一个回调函数，该回调函数接受三个参数：当前遍历的元素、当前元素的索引和正在遍历的数组。在示例中，我们只使用了第一个参数 element，即当前遍历的元素。

回调函数中的 return 语句用于指定条件判断。在示例中，我们判断每个元素是否大于 3，当找到第一个满足条件的元素时，就会返回该元素的索引值。

findIndex() 方法会依次遍历数组的每个元素，如果找到满足条件的元素，则返回该元素的索引值；如果所有元素都不满足条件，则返回 -1。

其他

24.Array.from()

Array.from() 方法用于将可迭代对象（如数组、类数组对象、字符串等）转换为一个新的数组实例。以下是一个使用 Array.from() 方法的示例

const str = "Hello";
const array = Array.from(str);

console.log(array);
// 输出：["H", "e", "l", "l", "o"]

在上面的示例中，我们定义了一个名为 str 的字符串变量，内容为 "Hello"。然后，我们使用 Array.from() 方法将该字符串转换为一个新的数组实例。

Array.from() 方法的第一个参数是要转换的可迭代对象。在示例中，我们传入了字符串 str，它被视为一个类数组对象，可以逐个访问其字符。

Array.from() 方法会遍历可迭代对象的每个元素，并将每个元素放入新的数组中。在示例中，每个字符都被作为一个独立的元素放入了新的数组中。

转换后的数组被存储在名为 array 的变量中，并通过 console.log() 方法打印出来。输出结果是一个包含字符串中每个字符的数组。

25.Array.isArray()

Array.isArray() 方法用于检查一个值是否为数组。以下是一个使用 Array.isArray() 方法的示例：

const array = [1, 2, 3];

console.log(Array.isArray(array));
// 输出：true

const str = "Hello";

console.log(Array.isArray(str));
// 输出：false

在上面的示例中，我们定义了一个名为 array 的数组变量，内容为 [1, 2, 3]。然后，我们使用 Array.isArray() 方法检查 array 是否为数组。

Array.isArray() 方法的参数是要检查的值。在示例中，我们传入了变量 array，它是一个数组。

通过调用 Array.isArray(array)，我们可以判断 array 是否为数组。如果是数组，则返回 true；如果不是数组，则返回 false。

在示例中，由于 array 是一个数组，所以调用 Array.isArray(array) 返回的结果是 true。

另外，我们还定义了一个名为 str 的字符串变量，并使用 Array.isArray() 方法检查 str 是否为数组。由于 str 是一个字符串，不是数组，所以调用 Array.isArray(str) 返回的结果是 false。

26.Array.of()

Array.of() 方法用于创建一个包含任意数量参数的新数组实例。以下是一个使用 Array.of() 方法的示例：

const array1 = Array.of(1, 2, 3);

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

const array2 = Array.of("Hello", "world");

console.log(array2);
// 输出：["Hello", "world"]

const array3 = Array.of(1, "Hello", true);

console.log(array3);
// 输出：[1, "Hello", true]

在上面的示例中，我们分别使用 Array.of() 方法创建了三个新的数组实例。

首先，我们在第一行中使用 Array.of(1, 2, 3) 创建了一个包含三个元素的新数组。这里我们传入了三个参数，每个参数都被作为独立的元素放入了新数组中。

在第二个示例中，我们创建了一个包含两个字符串元素的新数组，每个字符串都被视为一个独立的元素。

在第三个示例中，我们创建了一个包含三个不同类型的元素的数组，每个元素都被视为一个独立的元素。注意，在使用 Array.of() 方法时，参数可以是任意数量、任意类型的值。

对象方法

原型链相关

27.hasOwnProperty()

const obj = {
  name: "Alice",
  age: 25
};

console.log(obj.hasOwnProperty("name"));
// 输出：true
console.log(obj.hasOwnProperty("toString"));
// 输出：false

在上面的示例中，我们定义了一个名为 obj 的对象变量，包含两个属性：name 和 age。

然后，我们使用 hasOwnProperty() 方法检查 obj 对象是否包含 name 属性。由于 name 是 obj 对象自身的属性，obj.hasOwnProperty("name") 返回 true。

接着，我们使用 hasOwnProperty() 方法检查 obj 对象是否包含 toString 属性。由于 toString 属性是从 Object.prototype 继承而来的，而不是 obj 对象自身的属性，obj.hasOwnProperty("toString") 返回 false。

29.isPrototypeOf()

isPrototypeOf() 方法用于检查一个对象是否存在于另一个对象的原型链中。以下是一个使用 isPrototypeOf() 方法的示例：

function Animal() {}

function Cat() {}
Cat.prototype = Object.create(Animal.prototype);

const animal = new Animal();
const cat = new Cat();

console.log(Animal.prototype.isPrototypeOf(animal));
// 输出：true

console.log(Animal.prototype.isPrototypeOf(cat));
// 输出：true

console.log(Cat.prototype.isPrototypeOf(animal));
// 输出：false

console.log(Cat.prototype.isPrototypeOf(cat));
// 输出：true

在上面的示例中，我们定义了 Animal 和 Cat 两个构造函数，并通过 Cat.prototype = Object.create(Animal.prototype) 将 Cat 的原型设置为 Animal 的实例。这样，Cat 继承了 Animal 的原型链。

然后，我们分别创建了一个 animal 对象和一个 cat 对象。animal 是 Animal 的实例，cat 是 Cat 的实例。

接着，我们使用 isPrototypeOf() 方法来检查对象之间的原型链关系。

首先，我们调用 Animal.prototype.isPrototypeOf(animal) 来检查 Animal.prototype 是否存在于 animal 对象的原型链中。由于 animal 是 Animal 的实例，所以 Animal.prototype 存在于 animal 的原型链中，返回 true。

然后，我们调用 Animal.prototype.isPrototypeOf(cat) 来检查 Animal.prototype 是否存在于 cat 对象的原型链中。由于 cat 是 Cat 的实例，而 Cat 的原型链中包含 Animal.prototype，所以 Animal.prototype 存在于 cat 的原型链中，返回 true。

接下来，我们调用 Cat.prototype.isPrototypeOf(animal) 来检查 Cat.prototype 是否存在于 animal 对象的原型链中。由于 animal 不是 Cat 的实例，而是 Animal 的实例，所以 Cat.prototype 不存于 animal 的原型链中，返回 false。

最后，我们调用 Cat.prototype.isPrototypeOf(cat) 来检查 Cat.prototype 是否存在于 cat 对象的原型链中。由于 cat 是 Cat 的实例，所以 Cat.prototype 存在于 cat 的原型链中，返回 true。

30.propertyIsEnumerable()

propertyIsEnumerable() 方法用于检查一个属性是否可枚举（即是否可以使用 for...in 循环遍历）。以下是一个使用 propertyIsEnumerable() 方法的示例：

const obj = {
  name: "Alice",
  age: 25
};

console.log(obj.propertyIsEnumerable("name"));
// 输出：true

console.log(obj.propertyIsEnumerable("toString"));
// 输出：false

console.log(obj.propertyIsEnumerable("valueOf"));
// 输出：false

在上面的示例中，我们定义了一个名为 obj 的对象变量，包含两个属性：name 和 age。

然后，我们使用 propertyIsEnumerable() 方法检查 obj 对象的属性是否可枚举。

首先，我们调用 obj.propertyIsEnumerable("name") 来检查 obj 对象的 name 属性是否可枚举。由于 name 属性是 obj 对象自身的属性，并且默认情况下是可枚举的，所以 obj.propertyIsEnumerable("name") 返回 true。

接着，我们调用 obj.propertyIsEnumerable("toString") 来检查 obj 对象的 toString 属性是否可枚举。由于 toString 属性是从 Object.prototype 继承而来的，并且在默认情况下是不可枚举的，所以 obj.propertyIsEnumerable("toString") 返回 false。

最后，我们调用 obj.propertyIsEnumerable("valueOf") 来检查 obj 对象的 valueOf 属性是否可枚举。由于 valueOf 属性是从 Object.prototype 继承而来的，并且在默认情况下是不可枚举的，所以 obj.propertyIsEnumerable("valueOf") 返回 false。

静态方法

31.Object.assign()

Object.assign() 方法用于将一个或多个源对象的属性复制到目标对象中。以下是一个使用 Object.assign() 方法的示例：

const target = { name: "Alice", age: 25 };
const source1 = { age: 30 };
const source2 = { address: "Beijing" };

const result = Object.assign(target, source1, source2);

console.log(result);
// 输出：{ name: "Alice", age: 30, address: "Beijing" }

在上面的示例中，我们定义了一个名为 target 的目标对象，包含两个属性：name 和 age。

然后，我们定义了两个源对象：source1 包含一个 age 属性，source2 包含一个 address 属性。

接着，我们调用 Object.assign() 方法将 source1 和 source2 对象的属性复制到 target 对象中。Object.assign() 方法的第一个参数是目标对象，后面是一个或多个源对象。如果多个源对象具有相同的属性，则后面的属性会覆盖前面的属性。

在上面的示例中，source1 对象的 age 属性覆盖了 target 对象的 age 属性，source2 对象的 address 属性被添加到了 target 对象中。

最后，Object.assign() 方法返回修改后的 target 对象，并将其赋值给变量 result。

32.Object.create()

Object.create() 方法用于创建一个新对象，该对象的原型链将指向指定的原型对象。以下是一个使用 Object.create() 方法的示例：

const person = {
  greet: function() {
    console.log(`Hello, my name is ${this.name}.`);
  }
};

const alice = Object.create(person);
alice.name = "Alice";

alice.greet();
// 输出：Hello, my name is Alice.

在上面的示例中，我们定义了一个名为 person 的对象，其中包含一个 greet 方法用于打印问候语。

然后，我们使用 Object.create() 方法创建了一个名为 alice 的新对象，并将 person 对象作为其原型对象。这样，alice 对象就继承了 person 对象的属性和方法。

接着，我们为 alice 对象添加一个 name 属性，并将其设置为 "Alice"。

最后，我们调用 alice.greet() 方法，输出 "Hello, my name is Alice."。由于 alice 对象的原型链指向 person 对象，所以 alice 对象可以访问 person 对象的方法。

33.Object.defineProperty()

Object.defineProperty() 方法用于在对象上定义一个新属性或修改现有属性的特性。以下是一个使用 Object.defineProperty() 方法的示例：

const obj = {};

Object.defineProperty(obj, "name", {
  value: "Alice",
  writable: false,
  enumerable: true,
  configurable: true
});

console.log(obj.name);
// 输出：Alice

obj.name = "Bob";
console.log(obj.name);
// 输出：Alice

在上面的示例中，我们定义了一个空对象 obj。

然后，我们使用 Object.defineProperty() 方法在 obj 对象上定义了一个名为 name 的新属性。我们通过传递一个属性描述符对象作为第三个参数来定义属性的特性。

属性描述符对象包含了要定义的属性的各种特性，如 value（属性的值），writable（属性是否可写），enumerable（属性是否可枚举）和 configurable（属性是否可配置）等。

在上面的示例中，我们将 name 属性的值设置为 "Alice"，并将 writable 特性设置为 false，表示该属性不可写。我们将 enumerable 特性设置为 true，表示该属性可枚举。同时，我们将 configurable 特性设置为 true，表示该属性可配置。

接着，我们通过 console.log(obj.name) 打印 name 属性的值，输出为 "Alice"。

最后，我们尝试将 obj.name 的值修改为 "Bob"，但由于 writable 特性被设置为 false，所以赋值操作无效。再次打印 obj.name，输出仍然是 "Alice"。

34.Object.defineProperties()

Object.defineProperties() 方法用于在对象上定义多个新属性或修改现有属性的特性。以下是一个使用 Object.defineProperties() 方法的示例：

const obj = {};

Object.defineProperties(obj, {
  name: {
    value: "Alice",
    writable: false,
    enumerable: true,
    configurable: true
  },
  age: {
    value: 25,
    writable: true,
    enumerable: true,
    configurable: true
  }
});

console.log(obj.name);
// 输出：Alice

obj.name = "Bob";
console.log(obj.name);
// 输出：Alice

console.log(obj.age);
// 输出：25

obj.age = 30;
console.log(obj.age);
// 输出：30

在上面的示例中，我们定义了一个空对象 obj。

然后，我们使用 Object.defineProperties() 方法在 obj 对象上定义了两个新属性：name 和 age。我们通过传递一个包含多个属性描述符对象的对象作为第二个参数来定义属性的特性。

每个属性描述符对象都包含了要定义的属性的各种特性，如 value（属性的值），writable（属性是否可写），enumerable（属性是否可枚举）和 configurable（属性是否可配置）等。

在上面的示例中，我们将 name 属性的值设置为 "Alice"，并将 writable 特性设置为 false，表示该属性不可写。我们将 enumerable 特性设置为 true，表示该属性可枚举。同时，我们将 configurable 特性设置为 true，表示该属性可配置。

我们还将 age 属性的值设置为 25，并将 writable 特性设置为 true，表示该属性可写。我们同样将 enumerable 特性设置为 true，表示该属性可枚举。同时，我们将 configurable 特性设置为 true，表示该属性可配置。

接着，我们通过 console.log(obj.name) 打印 name 属性的值，输出为 "Alice"。然后，我们尝试将 obj.name 的值修改为 "Bob"，但由于 writable 特性被设置为 false，所以赋值操作无效。再次打印 obj.name，输出仍然是 "Alice"。

接着，我们通过 console.log(obj.age) 打印 age 属性的值，输出为 25。然后，我们将 obj.age 的值修改为 30，赋值操作成功。再次打印 obj.age，输出为 30。

35.Object.entries()

Object.entries() 方法用于将对象的可枚举属性转换为一个包含键值对的数组。以下是一个使用 Object.entries() 方法的示例：

const obj = {
  name: "Alice",
  age: 25,
  city: "New York"
};

const entries = Object.entries(obj);

console.log(entries);
// 输出：[["name", "Alice"], ["age", 25], ["city", "New York"]]

在上面的示例中，我们有一个名为 obj 的对象，它包含了三个属性：name、age 和 city。

然后，我们使用 Object.entries() 方法将 obj 对象的可枚举属性转换为一个数组，并将结果保存在 entries 变量中。

最后，我们通过 console.log(entries) 打印 entries 数组，输出为 [["name", "Alice"], ["age", 25], ["city", "New York"]]。每个子数组都表示一个键值对，其中第一个元素是属性的键，第二个元素是属性的值。

这样，我们就可以使用 Object.entries() 方法将对象的属性和对应的值以键值对的形式存储在数组中，方便进行遍历和操作。

36.Object.freeze()

Object.freeze() 方法用于冻结对象，使其属性不可修改、删除或添加新属性。以下是一个使用 Object.freeze() 方法的示例：

const obj = {
  name: "Alice",
  age: 25,
  city: "New York"
};

Object.freeze(obj);

obj.name = "Bob";
obj.age = 30;
obj.gender = "female";
delete obj.city;

console.log(obj);
// 输出：{ name: "Alice", age: 25, city: "New York" }

console.log(Object.isFrozen(obj));
// 输出：true

在上面的示例中，我们有一个名为 obj 的对象，它包含了三个属性：name、age 和 city。

然后，我们使用 Object.freeze() 方法将 obj 对象冻结，使其属性不可修改、删除或添加新属性。

接着，我们尝试修改 obj 对象的属性值，将 name 属性的值修改为 "Bob"，将 age 属性的值修改为 30，尝试添加一个新属性 gender，以及尝试删除 city 属性。

但由于我们已经使用 Object.freeze() 冻结了 obj 对象，这些操作都将无效。

最后，我们通过 console.log(obj) 打印 obj 对象，输出仍然是 { name: "Alice", age: 25, city: "New York" }，即对象的属性没有被修改。

另外，我们使用 Object.isFrozen(obj) 方法检查 obj 对象是否被冻结，输出为 true，表示对象已被冻结。

37.Object.getOwnPropertyDescriptor()

Object.getOwnPropertyDescriptor() 方法用于获取指定对象属性的属性描述符。以下是一个使用 Object.getOwnPropertyDescriptor() 方法的示例：

const obj = {
  name: "Alice",
  age: 25,
  city: "New York"
};

const descriptor = Object.getOwnPropertyDescriptor(obj, "name");

console.log(descriptor);
// 输出：{ value: "Alice", writable: true, enumerable: true, configurable: true }

在上面的示例中，我们有一个名为 obj 的对象，它包含了三个属性：name、age 和 city。

然后，我们使用 Object.getOwnPropertyDescriptor() 方法获取 obj 对象的 name 属性的属性描述符，并将结果保存在 descriptor 变量中。

最后，我们通过 console.log(descriptor) 打印 descriptor 对象，输出为 { value: "Alice", writable: true, enumerable: true, configurable: true }。这个对象表示 name 属性的属性特性，包括属性的值、可写性、可枚举性和可配置性等。

通过使用 Object.getOwnPropertyDescriptor() 方法，我们可以获取指定对象属性的属性描述符，从而了解属性的特性和配置信息。

38.Object.getOwnPropertyDescriptors()

Object.getOwnPropertyDescriptors() 方法用于获取指定对象所有属性的属性描述符。以下是一个使用 Object.getOwnPropertyDescriptors() 方法的示例：

const obj = {
  name: "Alice",
  age: 25,
  city: "New York"
};

const descriptors = Object.getOwnPropertyDescriptors(obj);

console.log(descriptors);
/*
输出：
{
  name: { value: 'Alice', writable: true, enumerable: true, configurable: true },
  age: { value: 25, writable: true, enumerable: true, configurable: true },
  city: { value: 'New York', writable: true, enumerable: true, configurable: true }
}
*/

在上面的示例中，我们有一个名为 obj 的对象，它包含了三个属性：name、age 和 city。

然后，我们使用 Object.getOwnPropertyDescriptors() 方法获取 obj 对象的所有属性的属性描述符，并将结果保存在 descriptors 变量中。

最后，我们通过 console.log(descriptors) 打印 descriptors 对象，输出为包含每个属性及其对应属性描述符的对象。每个属性描述符对象包含属性的值、可写性、可枚举性和可配置性等信息。

通过使用 Object.getOwnPropertyDescriptors() 方法，我们可以获取指定对象所有属性的属性描述符，方便进行属性的深度复制、属性的批量定义等操作。

39.Object.getOwnPropertyNames()

Object.getOwnPropertyNames() 方法用于获取指定对象的所有属性名（包括不可枚举属性）。以下是一个使用 Object.getOwnPropertyNames() 方法的示例：

const obj = {
  name: "Alice",
  age: 25,
  city: "New York"
};

const propertyNames = Object.getOwnPropertyNames(obj);

console.log(propertyNames);
// 输出：[ 'name', 'age', 'city' ]

在上面的示例中，我们有一个名为 obj 的对象，它包含了三个属性：name、age 和 city。

然后，我们使用 Object.getOwnPropertyNames() 方法获取 obj 对象的所有属性名，并将结果保存在 propertyNames 数组中。

最后，我们通过 console.log(propertyNames) 打印 propertyNames 数组，输出为 ['name', 'age', 'city']，表示 obj 对象的所有属性名。

注意，Object.getOwnPropertyNames() 方法只返回对象自身的属性名，不包括原型链上的属性。如果需要获取对象自身和继承的所有可枚举属性名，可以使用 for...in 循环

40.Object.getOwnPropertySymbols()

Object.getOwnPropertySymbols() 方法用于获取指定对象的所有 Symbol 类型的属性。以下是一个使用 Object.getOwnPropertySymbols() 方法的示例：

const obj = {
  [Symbol("key1")]: "value1",
  [Symbol("key2")]: "value2",
  name: "Alice"
};

const symbols = Object.getOwnPropertySymbols(obj);

console.log(symbols);
// 输出：[Symbol(key1), Symbol(key2)]

在上面的示例中，我们有一个名为 obj 的对象，它包含了三个属性：两个 Symbol 类型的属性 [Symbol("key1")] 和 [Symbol("key2")]，以及一个普通的属性 name。

然后，我们使用 Object.getOwnPropertySymbols() 方法获取 obj 对象的所有 Symbol 类型的属性，并将结果保存在 symbols 数组中。

最后，我们通过 console.log(symbols) 打印 symbols 数组，输出为 [Symbol(key1), Symbol(key2)]，表示 obj 对象的所有 Symbol 类型的属性。

注意，Object.getOwnPropertySymbols() 方法只返回对象自身的 Symbol 类型的属性，不包括原型链上的属性。如果需要获取对象自身和继承的所有 Symbol 类型的属性，可以使用 Reflect.ownKeys() 方法。

41.Object.getPrototypeOf()

Object.getPrototypeOf() 方法用于获取指定对象的原型（即 __proto__ 属性）。以下是一个使用 Object.getPrototypeOf() 方法的示例：

const obj = {
  name: "Alice",
  age: 25
};

const prototype = Object.getPrototypeOf(obj);

console.log(prototype);
// 输出：{}

在上面的示例中，我们有一个名为 obj 的对象，它包含了两个属性：name 和 age。

然后，我们使用 Object.getPrototypeOf() 方法获取 obj 对象的原型，并将结果保存在 prototype 变量中。

最后，我们通过 console.log(prototype) 打印 prototype 变量，输出为 {}，表示 obj 对象的原型为一个空对象。

注意，Object.getPrototypeOf() 方法只返回指定对象的原型，不包括原型链上的其他原型。如果需要获取对象的整个原型链，可以使用 Object.prototype.isPrototypeOf() 方法或 instanceof 运算符。

42.Object.is()

Object.is() 方法用于比较两个值是否严格相等。以下是使用 Object.is() 方法的示例：

console.log(Object.is(1, 1));
// 输出：true

console.log(Object.is("hello", "hello"));
// 输出：true

console.log(Object.is(true, true));
// 输出：true

console.log(Object.is(null, null));
// 输出：true

console.log(Object.is(undefined, undefined));
// 输出：true

console.log(Object.is(NaN, NaN));
// 输出：true

console.log(Object.is(0, -0));
// 输出：false

console.log(Object.is({}, {}));
// 输出：false

在上面的示例中，我们使用了 Object.is() 方法来比较不同类型的值。

• 对于相同的原始值（如数字、字符串、布尔值、null 和 undefined），它们的比较结果为 true。
• 对于 NaN，它与自身的比较结果也为 true。
• 但是，对于 0 和 -0 的比较，它们的比较结果为 false，因为在 JavaScript 中，0 和 -0 被视为不同的值。
• 对于两个不同的对象字面量或通过构造函数创建的对象，它们的比较结果为 false。

Object.is() 方法类似于严格相等运算符（===），但有几个区别。例如，Object.is(+0, -0) 的比较结果为 false，而 +0 === -0 的比较结果为 true。

43.Object.preventExtensions()

Object.preventExtensions() 方法用于阻止对象添加新的属性或方法。以下是使用 Object.preventExtensions() 方法的示例：

const obj = {
  name: "Alice",
  age: 25
};

console.log(Object.isExtensible(obj));
// 输出：true

Object.preventExtensions(obj);

console.log(Object.isExtensible(obj));
// 输出：false

obj.gender = "female";
console.log(obj.gender);
// 输出：undefined

在上面的示例中，我们有一个名为 obj 的对象，它包含了两个属性：name 和 age。

首先，我们使用 Object.isExtensible() 方法检查 obj 对象是否可扩展，即是否可以添加新的属性或方法。通过 console.log(Object.isExtensible(obj)) 输出 true。

然后，我们使用 Object.preventExtensions() 方法阻止 obj 对象添加新的属性或方法。

接着，我们再次使用 Object.isExtensible() 方法检查 obj 对象是否可扩展，通过 console.log(Object.isExtensible(obj)) 输出 false，表示 obj 对象已经被阻止扩展。

最后，我们尝试向 obj 对象添加一个新的属性 gender，但由于我们已经调用了 Object.preventExtensions(obj) 方法，所以 obj 对象不会添加这个新属性。通过 console.log(obj.gender) 输出 undefined。

使用 Object.preventExtensions() 方法可以限制对象的扩展性，防止在运行时意外地添加新的属性或方法。但请注意，这个方法只能阻止添加新的属性或方法，已有属性或方法仍然可以修改或删除。

44.Object.seal()

Object.seal() 方法用于封闭一个对象，使其现有的属性不可删除，并且现有的属性的可写性被设置为 false。以下是使用 Object.seal() 方法的示例：

const obj = {
  name: "Alice",
  age: 25
};

console.log(Object.isSealed(obj));
// 输出：false

Object.seal(obj);

console.log(Object.isSealed(obj));
// 输出：true

delete obj.name;
console.log(obj.name);
// 输出："Alice"

obj.age = 30;
console.log(obj.age);
// 输出：30

在上面的示例中，我们有一个名为 obj 的对象，它包含了两个属性：name 和 age。

首先，我们使用 Object.isSealed() 方法检查 obj 对象是否已经被封闭，即是否不可删除属性并且属性的可写性被设置为 false。通过 console.log(Object.isSealed(obj)) 输出 false。

然后，我们使用 Object.seal() 方法封闭 obj 对象，使其现有的属性不可删除，并将现有的属性的可写性设置为 false。

接着，我们再次使用 Object.isSealed() 方法检查 obj 对象是否已经被封闭，通过 console.log(Object.isSealed(obj)) 输出 true，表示 obj 对象已经被封闭。

最后，我们尝试删除 obj 对象的 name 属性，但由于 obj 对象已经被封闭，所以无法删除属性。通过 console.log(obj.name) 输出 "Alice"，表示 name 属性仍然存在。

我们还尝试修改 obj 对象的 age 属性，由于 obj 对象已经被封闭，所以无法修改属性的值。通过 console.log(obj.age) 输出 30，表示 age 属性的值没有被修改。

使用 Object.seal() 方法可以保护对象的属性不被删除，并且属性的可写性被设置为 false，但属性的值可以被修改。

45.Object.keys()

Object.keys() 方法返回一个由对象的可枚举属性组成的数组。以下是使用 Object.keys() 方法的示例：

const obj = {
  name: "Alice",
  age: 25,
  gender: "female"
};

const keys = Object.keys(obj);

console.log(keys);
// 输出：["name", "age", "gender"]

在上面的示例中，我们有一个名为 obj 的对象，它包含了三个属性：name、age 和 gender。

我们使用 Object.keys() 方法将 obj 对象的可枚举属性转换为一个数组，并将结果存储在 keys 变量中。

通过 console.log(keys) 输出 ["name", "age", "gender"]，表示 obj 对象的可枚举属性组成的数组。

使用 Object.keys() 方法可以方便地获取对象的所有可枚举属性，并将其转换为数组进行进一步处理。

46.Object.values()

Object.values() 方法返回一个由对象的可枚举属性值组成的数组。以下是使用 Object.values() 方法的示例

const obj = {
  name: "Alice",
  age: 25,
  gender: "female"
};

const values = Object.values(obj);

console.log(values);
// 输出：["Alice", 25, "female"]

在上面的示例中，我们有一个名为 obj 的对象，它包含了三个属性：name、age 和 gender。

我们使用 Object.values() 方法将 obj 对象的可枚举属性值转换为一个数组，并将结果存储在 values 变量中。

通过 console.log(values) 输出 ["Alice", 25, "female"]，表示 obj 对象的可枚举属性值组成的数组。

使用 Object.values() 方法可以方便地获取对象的所有可枚举属性值，并将其转换为数组进行进一步处理。

47.Object.isFrozen()

Object.isFrozen() 方法用于检查对象是否被冻结，即对象的属性不可添加、删除或修改。以下是使用 Object.isFrozen() 方法的示例：

const obj = {
  name: "Alice",
  age: 25
};

console.log(Object.isFrozen(obj));
// 输出：false

Object.freeze(obj);

console.log(Object.isFrozen(obj));
// 输出：true

obj.name = "Bob";
console.log(obj.name);
// 输出："Alice"

delete obj.age;
console.log(obj.age);
// 输出：25

在上面的示例中，我们有一个名为 obj 的对象，它包含了两个属性：name 和 age。

首先，我们使用 Object.isFrozen() 方法检查 obj 对象是否已经被冻结，即对象的属性不可添加、删除或修改。通过 console.log(Object.isFrozen(obj)) 输出 false。

然后，我们使用 Object.freeze() 方法冻结 obj 对象，使其属性不可添加、删除或修改。

接着，我们再次使用 Object.isFrozen() 方法检查 obj 对象是否已经被冻结，通过 console.log(Object.isFrozen(obj)) 输出 true，表示 obj 对象已经被冻结。

最后，我们尝试修改 obj 对象的 name 属性，但由于 obj 对象已经被冻结，所以无法修改属性的值。通过 console.log(obj.name) 输出 "Alice"，表示 name 属性的值没有被修改。

我们还尝试删除 obj 对象的 age 属性，但由于 obj 对象已经被冻结，所以无法删除属性。通过 console.log(obj.age) 输出 25，表示 age 属性仍然存在。

使用 Object.freeze() 方法可以保护对象的属性不被添加、删除或修改。

48.Object.isSealed()

Object.isSealed() 方法用于检查对象是否被密封，即已有的属性不可删除，但属性值可以修改。以下是使用 Object.isSealed() 方法的示例：

const obj = {
  name: "Alice",
  age: 25
};

console.log(Object.isSealed(obj));
// 输出：false

Object.seal(obj);

console.log(Object.isSealed(obj));
// 输出：true

obj.name = "Bob";
console.log(obj.name);
// 输出："Bob"

delete obj.age;
console.log(obj.age);
// 输出：undefined

在上面的示例中，我们有一个名为 obj 的对象，它包含了两个属性：name 和 age。

首先，我们使用 Object.isSealed() 方法检查 obj 对象是否已经被密封，即已有的属性不可删除，但属性值可以修改。通过 console.log(Object.isSealed(obj)) 输出 false。

然后，我们使用 Object.seal() 方法密封 obj 对象，使其已有的属性不可删除，但属性值可以修改。

接着，我们再次使用 Object.isSealed() 方法检查 obj 对象是否已经被密封，通过 console.log(Object.isSealed(obj)) 输出 true，表示 obj 对象已经被密封。

最后，我们尝试修改 obj 对象的 name 属性，由于 obj 对象已经被密封，所以可以修改属性的值。通过 console.log(obj.name) 输出 "Bob"，表示 name 属性的值已经被修改。

我们还尝试删除 obj 对象的 age 属性，但由于 obj 对象已经被密封，所以无法删除属性。通过 console.log(obj.age) 输出 undefined，表示 age 属性已经被删除了。

使用 Object.seal() 方法可以保护对象的已有属性不被删除，但属性值可以修改。

49.Object.isExtensible()

Object.isExtensible() 方法用于检查对象是否可扩展，即对象是否可以添加新的属性。以下是使用 Object.isExtensible() 方法的示例：

const obj = {
  name: "Alice",
  age: 25
};

console.log(Object.isExtensible(obj));
// 输出：true

Object.preventExtensions(obj);

console.log(Object.isExtensible(obj));
// 输出：false

obj.city = "New York";
console.log(obj.city);
// 输出：undefined

在上面的示例中，我们有一个名为 obj 的对象，它包含了两个属性：name 和 age。

首先，我们使用 Object.isExtensible() 方法检查 obj 对象是否可扩展，即对象是否可以添加新的属性。通过 console.log(Object.isExtensible(obj)) 输出 true。

然后，我们使用 Object.preventExtensions() 方法阻止 obj 对象的扩展，使其不可再添加新的属性。

接着，我们再次使用 Object.isExtensible() 方法检查 obj 对象是否可扩展，通过 console.log(Object.isExtensible(obj)) 输出 false，表示 obj 对象已经不可再添加新的属性。

最后，我们尝试添加新的属性 city 到 obj 对象，但由于 obj 对象已经不可扩展，所以无法添加新的属性。通过 console.log(obj.city) 输出 undefined，表示 city 属性没有被添加到 obj 对象中。

使用 Object.preventExtensions() 方法可以阻止对象的扩展，即对象不可再添加新的属性。

50.Object.setPrototypeOf()

Object.setPrototypeOf() 方法用于设置一个对象的原型（即 prototype）。以下是使用 Object.setPrototypeOf() 方法的示例：

const obj = {
  name: "Alice",
  age: 25
};

const newObj = {
  city: "New York"
};

Object.setPrototypeOf(newObj, obj);

console.log(newObj.name);
// 输出："Alice"

console.log(newObj.age);
// 输出：25

console.log(newObj.city);
// 输出："New York"

在上面的示例中，我们有两个对象：obj 和 newObj。

首先，我们定义了一个名为 obj 的对象，它包含了两个属性：name 和 age。

然后，我们定义了一个名为 newObj 的对象，它包含了一个属性 city。

接着，我们使用 Object.setPrototypeOf() 方法将 newObj 对象的原型设置为 obj 对象，即 newObj 对象继承自 obj 对象。

最后，我们通过 console.log(newObj.name)、console.log(newObj.age) 和 console.log(newObj.city) 分别输出了 newObj 对象的属性值，即继承自 obj 对象的 name 和 age 属性，以及自身的 city 属性。

使用 Object.setPrototypeOf() 方法可以设置一个对象的原型，使其继承自另一个对象。