数组方法
改变数组的方法
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()
方法的示例:
- 删除元素:
let arr = ['apple', 'banana', 'orange']; arr.splice(1, 1); // 从索引位置 1 开始删除一个元素 console.log(arr); // 输出: ['apple', 'orange']
在上面的示例中,我们有一个名为
arr
的数组,包含三个元素:'apple'、'banana' 和 'orange'。通过调用splice()
方法并传入参数 1 和 1,我们从索引位置 1 开始删除了一个元素。最后,我们打印出更新后的arr
数组。 - 替换元素:
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
数组。 - 插入元素:
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()
方法的示例:
- 合并数组:
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
。 - 合并值和数组:
let arr = ['apple', 'banana']; let newArr = arr.concat('orange', ['grape']); console.log(newArr); // 输出: ['apple', 'banana', 'orange', 'grape']
在上面的示例中,我们有一个数组
arr
,包含两个元素。通过调用concat()
方法并传入字符串'orange'
和数组['grape']
,我们将这些值和数组合并成一个新数组newArr
。最后,我们打印出新数组newArr
。 - 合并多个数组:
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()
方法的示例:
- 使用默认分隔符:
let arr = ['apple', 'banana', 'orange']; let str = arr.join(); console.log(str); // 输出: "apple,banana,orange"
在上面的示例中,我们有一个名为
arr
的数组,包含三个元素:'apple'、'banana' 和 'orange'。通过调用join()
方法,它会将数组中的所有元素转换为一个字符串,并使用默认的逗号分隔符连接它们。最后,我们打印出连接后的字符串str
。 - 使用自定义分隔符
let arr = ['apple', 'banana', 'orange']; let str = arr.join('-'); console.log(str); // 输出: "apple-banana-orange"
在上面的示例中,我们有一个名为
arr
的数组,包含三个元素:'apple'、'banana' 和 'orange'。通过调用join('-')
方法,它会将数组中的所有元素转换为一个字符串,并使用自定义的连字符分隔符连接它们。最后,我们打印出连接后的字符串str
。 - 连接数字数组:
let arr = [1, 2, 3]; let str = arr.join(''); console.log(str); // 输出: "123"
在上面的示例中,我们有一个名为
arr
的数组,包含三个元素:1、2 和 3。通过调用join('')
方法,它会将数组中的所有元素转换为一个字符串,并使用空字符串作为分隔符连接它们。由于数组中的元素都是数字,它们会被转换为字符串并连接在一起。最后,我们打印出连接后的字符串str
。
10.slice() 方法
slice()
方法是 JavaScript 字符串和数组的一个方法,用于从原始字符串或数组中提取出指定部分,并返回一个新的字符串或数组,而不会修改原始字符串或数组。
下面是一些 slice()
方法的示例:
- 提取字符串的一部分:
let str = "Hello, World!"; let newStr = str.slice(7, 12); console.log(newStr); // 输出: "World"
在上面的示例中,我们有一个名为
str
的字符串。通过调用slice(7, 12)
方法,它会从索引位置 7 开始提取字符串,并一直提取到索引位置 12(不包括该位置),得到一个新的字符串newStr
。最后,我们打印出提取出的新字符串newStr
。 - 提取数组的一部分:
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
。 - 不带参数的使用:
let str = "Hello, World!"; let newStr = str.slice(); console.log(newStr); // 输出: "Hello, World!"
在上面的示例中,我们有一个名为
str
的字符串。通过调用slice()
方法而不传递任何参数,它会返回原始字符串的副本,即与原始字符串相同的新字符串newStr
。最后,我们打印出新字符串newStr
。
11.toString()
toString()
方法是 JavaScript 中的一个方法,用于将一个值转换为字符串。
下面是一些 toString()
方法的示例:
- 转换数字为字符串:
let num = 123; let str = num.toString(); console.log(str); // 输出: "123"
在上面的示例中,我们有一个名为
num
的数字。通过调用toString()
方法,它会将数字转换为字符串,并赋值给变量str
。最后,我们打印出转换后的字符串str
。 - 转换布尔值为字符串:
let bool = true; let str = bool.toString(); console.log(str); // 输出: "true"
在上面的示例中,我们有一个名为
bool
的布尔值。通过调用toString()
方法,它会将布尔值转换为字符串,并赋值给变量str
。最后,我们打印出转换后的字符串str
。 - 转换数组为字符串:
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()
方法的示例:
- 查找字符串中的子串:
let str = "Hello, World!"; let index = str.indexOf("World"); console.log(index); // 输出: 7
在上面的示例中,我们有一个名为
str
的字符串。通过调用indexOf("World")
方法,它会在字符串中查找子串 "World" 并返回其在字符串中的索引值。最后,我们打印出子串在字符串中的索引值index
。 - 查找数组中的元素:
let arr = [1, 2, 3, 4, 5]; let index = arr.indexOf(3); console.log(index); // 输出: 2
在上面的示例中,我们有一个名为
arr
的数组。通过调用indexOf(3)
方法,它会在数组中查找元素 3 并返回其在数组中的索引值。最后,我们打印出元素在数组中的索引值index
。 - 查找不存在的元素:
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()
方法的示例:
- 查找字符串中的子串:
let str = "Hello, World!"; let index = str.lastIndexOf("o"); console.log(index); // 输出: 8
在上面的示例中,我们有一个名为
str
的字符串。通过调用lastIndexOf("o")
方法,它会在字符串中从后向前查找字符 "o" 并返回最后一次出现的索引值。最后,我们打印出字符在字符串中的索引值index
。 - 查找数组中的元素:
let arr = [1, 2, 3, 4, 3]; let index = arr.lastIndexOf(3); console.log(index); // 输出: 4
在上面的示例中,我们有一个名为
arr
的数组。通过调用lastIndexOf(3)
方法,它会在数组中从后向前查找元素 3 并返回最后一次出现的索引值。最后,我们打印出元素在数组中的索引值index
。 - 查找不存在的元素:
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()
方法的示例:
- 检查字符串中是否包含子串:
let str = "Hello, World!"; let result = str.includes("World"); console.log(result); // 输出: true
在上面的示例中,我们有一个名为
str
的字符串。通过调用includes("World")
方法,它会检查字符串中是否包含子串 "World"。由于字符串中包含该子串,因此includes()
方法将返回true
。 - 检查数组中是否包含元素:
let arr = [1, 2, 3, 4, 5]; let result = arr.includes(3); console.log(result); // 输出: true
在上面的示例中,我们有一个名为
arr
的数组。通过调用includes(3)
方法,它会检查数组中是否包含元素 3。由于数组中包含该元素,因此includes()
方法将返回true
。 - 检查不存在的元素:
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()
方法可以设置一个对象的原型,使其继承自另一个对象。