1-JavaScript-ECMAScript核心-内建对象
before
本篇主要介绍js的内建的对象，学习其具体的属性和方法。
这里提前说一个概念，那就是：
- 破坏性方法，即对原数据进行操作，比如原地排序、反转数组。
- 非破坏性方法，不会影响原数据，而是经过一番如此这般之后，返回新的结果，比如两个字符串通过拼接方法进行拼接，会得到一个新的字符串，而不影响原来的两个字符串。
Array
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array
你可以把JavaScript中的数组(Array)当成Python中的列表。
什么是序列？
所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。
为了更形象的认识序列，可以将它看做是一家旅店，那么店中的每个房间就如同序列存储数据的一个个内存空间，每个房间所特有的房间号就相当于索引值。也就是说，通过房间号（索引）我们可以找到这家旅店（序列）中的每个房间（内存空间）。
序列中的每个元素都有一个序号，即元素的位置，也叫做索引、索引下标、下标索引，序列中的第一个元素索引为0，第二个索引为1，依此类推。
注意：JavaScript中序列编号机制是从0开始的，其他大部分的语言都是如此设计。另外，这里的序列如无特指，一律为有序序列。
Array也属于序列类型，它具有以上序列的特点。且，Array中可以存储JavaScript中的任意数据类型；如果数组中嵌套的还是数组，可以称为二维数组，如果嵌套更多层，可以称为多维数组，不过处理起来麻烦了，通常不这么干。
另外，虽然数组能存任意类型，但建议存储为同一类型的数据，便于处理。
最后，数组的长度没有限制。
基础操作
创建数组
// 通过new来声明一个空的数组
// let a = new Array();
// 也可以省略new，如下面两种简写方式，跟new Array()效果一样
// let a = Array();
let a = [];
// let a = ['a', 'b', 'c']; // 也可以有初始的元素
console.log(a, typeof a); // [] object
console.log(a instanceof Array); // true
添加/更新
let a = [];
// 通过索引添加或者更新元素
a[0] = 10; // 此时数组的0索引对应的位置没有数据，所以这个操作是添加元素
a[0] = 20; // 0索引在上一步已经赋值了，所以这里是更新
console.log(a[0]); // 通过索引取值
console.log(a[10]); // 数组中没有下标为10的索引，所以返回undefined
console.log(a.length); // 返回数组的元素的个数，即返回数组的长度
非连续性数组
let a = [];
a[0] = 10;
a[1] = 20;
a[2] = 30;
a[7] = 50;
a[5] = 70;
console.log(a); // [ 10, 20, 30, <2 empty items>, 70, <1 empty item>, 50 ]
console.log(a.length); // 8
// 借助length的特点，我们可以为数组追加元素
a[a.length] = 80;
console.log(a); // [ 10, 20, 30, <2 empty items>, 70, <1 empty item>, 50, 80 ]
// length的值可以修改
// length值改小
a.length = 2; // 从右到左进行删除，保留两个元素
console.log(a); // [ 10, 20 ]
// length值改大
a.length = 10; // 会将后续的下标值置为空
console.log(a); // [ 10, 20, <8 empty items> ]
如上例，如果不看打印结果，我们自数数的话，这个数组中元素的个书应该是5个，但a.length结果确是8个？？？？？
什么情况？这就要说一点，length的返回值取决于数组中索引下标最大的值加1，上例中最大的索引是7，加1后的结果是8，然后返回了...
那么这种情况和这样的数组都是不合理的，也不符合逻辑的。所以这种数组被称为非连续性数组，数组中非连续部分默认填充一个empty，表示这个索引位置的元素是空的。
在开发中，我们应该避免使用非连续性数组。
遍历数组
let a = ['a', 'b', 'c'];
// for循环遍历数组，正序
for (let i = 0; i < a.length; i++) {
console.log(i, a[i]);
}
// 倒叙遍历
for (let i = a.length - 1; i >= 0; i--) {
console.log(i, a[i]);
}
// for in 遍历,只能正序遍历
for (let i in a) {
console.log(i, a[i]);
}
// 新语法，拿到的直接就是元素，但兼容性有待加强
for (let i of a) {
console.log(i);
}
// 使用array的forEach，函数中的第一个参数是元素，第二个参数是索引，第三个参数就是被遍历的数组，用的不多
a.forEach(function (item, index, arr) {
console.log(index, item, arr);
});
最常用的就是最开始的for循环或forEach方法去遍历数组，比较灵活。
常用方法
添加和删除：push/pop/unshift/shift
let a = ['a', 'b', 'c'];
// 追加一个或多个元素，push再追加后，还会返回数组新的长度
// let res = a.push('d');
// a.push('x', 'y');
// console.log(a, res); // [ 'a', 'b', 'c', 'd', 'x', 'y' ] 4
// 从数组尾部删除元素，没有参数，一次只能删除一个元素，且将删除的元素返回
// let res = a.pop();
// console.log(a, res); // [ 'a', 'b' ] c
// 从数组头部插入一个或多个元素，并将数组的新的长度返回
// a.unshift('d');
// let res = a.unshift('x', 'y');
// console.log(a, res); // [ 'x', 'y', 'd', 'a', 'b', 'c' ] 6
// 删除数组头部元素，并将其返回
// let res = a.shift();
// console.log(a, res); // [ 'b', 'c' ] a
练习：
function Person(name, age) {
this.name = name;
this.age = age;
}
let p1 = new Person('沙和尚', 28);
let p2 = new Person('红孩儿', 10);
let p3 = new Person('猪八戒', 30);
let p4 = new Person('孙悟空', 16);
arr = [p1, p2, p3, p4];
// 请定义一个函数，并将成年人和未成年人分别存储(数组、对象都可以)
function func(arr) {
let res = {"未成年": [], "成年人": []};
for (let i = 0; i < arr.length; i++) {
if (arr[i].age >= 18) {
a['成年人'].push(arr[i]);
} else {
a['未成年'].push(arr[i]);
}
}
return res;
}
res = func(arr);
console.log(res);
判断数组元素是否存在：indexOf/includes
首先，判断指定元素是否存在，不能用in，因为js中，用in判断数组是判断索引位置是否存在的：
let a = ['a', 'b', 'c'];
console.log('a' in a); // false
// 索引1~2都是合法的，不在这范围之内都返回false
console.log(1 in a); // true
console.log(2 in a); // true
console.log(3 in a); // false
console.log(30 in a); // false
indexOf/lastIndexOf
// 判断指定元素在不在数组中
let a = ['a', 'b', 'c'];
// indexOf，从左到右找元素
// 第一个参数：要查找的元素
// 第二个参数: 不传参，即默认从0索引开始往右找，找到第一个返回其索引下标；你也可以指定从哪个索引开始找
// 找不到的话，返回 -1
console.log(a.indexOf('a')); // 0
// 从索引1开始往右找 "w"
console.log(a.indexOf('w', 1)); // -1
/*
lastIndexOf，从右到左找元素
第一个参数：要查找的元素
第二个参数: 不传参，即默认从最后索引开始往左找，找到第一个返回其索引下标
如果传值，即表示从指定索引开始往左找，找到第一个返回其索引下标
找不到的话，返回 -1
*/
let arr = ['a', 'b', 'a', 'b', 'e', 'e', 'b'];
// 从右开始往左找第一个，返回索引下标
console.log(arr.lastIndexOf('b')); // 6
// 从索引2开始往左找第一个出现的元素，返回其索引下标
console.log(arr.lastIndexOf('b', 2)); // 1
includes
let a = ['a', 'b', 'c'];
// includes如果在，返回true，否则返回false
console.log(a.includes('a'));
console.log(a.includes('w'));
拼接数组：join
join以指定符号将数组的元素拼接为字符串：
let arr = ['a', 'b', 'a', 'b', 'e', 'e', 'b'];
// 默认以逗号分割
console.log(arr.join()); // a,b,a,b,e,e,b
// 可以指定连接符号
console.log(arr.join('.')); // a.b.a.b.e.e.b
console.log(arr.join('-')); // a-b-a-b-e-e-b
console.log(arr.join('')); // ababeeb
反转：reverse
破坏性方法！reverse方法在原地对数组进行反转：
let arr = ['a', 'b', 'c', 'd'];
arr.reverse();
console.log(arr); // [ 'd', 'c', 'b', 'a' ]
数组排序：sort
破坏性方法！sort对数组进行排序：
let arr = ['c', 'd', 'a', 'b'];
// 默认升序排序
arr.sort(); // [ 'a', 'b', 'c', 'd' ]
// 想要降序排序的话，还是使用reverse吧
// arr.reverse();
使用sort对数组内的元素全是字符进行排序没有问题，因为它比较的字符在ASCII码表上的位置进行比较的，但要命的是，对于数字它也是按照这个规则来的：
let arr = [5, 3, 1, 2, 10, 18, 60];
// arr.sort(); // [ 1, 10, 18, 2, 3, 5, 60 ]
// 将数字转为字符串，然后按照ASCII码表进行排序，很明显不符合我们的需要
// 所以我们要自定义排序规则，而且规则非常简单固定
arr.sort(function (a, b) {
// 想要升序就a - b
// return a - b; // [ 1, 2, 3, 5, 10, 18, 60 ]
// 想要降序就b - a
return b - a; // [ 60, 18, 10, 5, 3, 2, 1 ]
});
console.log(arr);
对于数字类型的排序算法，内部使用的是什么算法，不同的浏览器有不同的实现。
- chrome v8，用的是混合算法，即插入算法（元素少，性能高）和快排（数组元素多），源码参考，[点我][https://github.com/v8/v8/blob/ad82a40509c5b5b4680d4299c8f08d6c6d31af3c/src/js/array.js]
- Firefox用的应该是归并。
切片和替换：slice/splice
slice用来对数组进行切片(截取)，参数：
- 截取的起始位置(包含起始位置)。
- 截取的结束位置索引(不包含结束位置)，如果截取结束位置不传参，表示从起始位置截取到数组的最后。
slice切片时，不会影响到原数组，而是将截取的结果以新的数组返回，所以该方法可以称为非破坏性方法。
let a = ['a', 'b', 'c', 'd'];
console.log(a.slice(1, 3)); // [ 'b', 'c' ]
console.log(a.slice(1)); // [ 'b', 'c', 'd' ]
// 索引可以传负值，-1表示数组倒数第一个元素下标；-2表示倒数第二个......
console.log(a.slice(1, -2)); // [ 'b' ]
splice可以用来删除、替换、添加数组中的元素，它是个破坏性方法，即它影响到原数组。
let a = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
/*
* 删除指定范围的元素
* 第一个参数：删除的起始位置(包含)
* 第二个参数：从删除元素的起始位置开始，向右删几个
* */
// let res;
// res= a.splice(2, 3); // 删除的元素: [ 'c', 'd' ] 原数组: [ 'a', 'b', 'e', 'f', 'g' ]
// console.log('删除的元素: ', res, ' 原数组: ', a);
/*
* 替换指定范围内的元素
* 第一个参数：起始位置(包含)
* 第二个参数：从起始位置，向右替换几个
* 第三或更个多参数：一个或多个元素将被替换到数组中去
* */
// let res;
// // res= a.splice(0, 2, '沙和尚'); // 删除的元素: [ 'a', 'b' ] 原数组: [ '沙和尚', 'c', 'd', 'e', 'f', 'g' ]
// res= a.splice(0, 2, '沙和尚', '白骨精', '蜘蛛精'); // 删除的元素: [ 'a', 'b' ] 原数组: [ '沙和尚', '白骨精', '蜘蛛精', 'c', 'd', 'e', 'f', 'g']
// console.log('删除的元素: ', res, ' 原数组: ', a);
/*
* 向指定位置插入元素
* 第一个参数：在该索引前面插入，值必须大于等于0
* 第二个参数：必须是0，否则就是替换了
* 第三或更个多参数：一个或多个元素将被插入到指定索引下标之前去
* */
// let res;
// // res = a.splice(0, 0, '沙和尚'); // 删除的元素: [ ] 原数组: ["沙和尚", "a", "b", "c", "d", "e", "f", "g"]
// res = a.splice(2, 0, '沙和尚', '白骨精', '蜘蛛精'); // 删除的元素: [ ] 原数组: ["a", "b", "沙和尚", "白骨精", "蜘蛛精", "c", "d", "e", "f", "g"]
// console.log('删除的元素: ', res, ' 原数组: ', a);
连接数组concat
concat用于连接多个数组，并不会影响原有数组，而是返回新的数组：
let arr1 = ['a', 'b'];
let arr2 = ['c', 'd'];
let arr3;
arr3 = arr1.concat(arr2); // [ 'a', 'b', 'c', 'd' ]
// 能多次自己连接自己
arr3 = arr1.concat(arr1, arr1, arr1); // [ 'a', 'b', 'a', 'b', 'a', 'b' ]
// 还能拼接单个值
arr3 = arr1.concat(arr1, 'x', 'y'); // [ 'a', 'b', 'a', 'b', 'x', 'y' ]
console.log(arr3);
数组去重
let arr = ['a', 'b', 'a', 'b', 'e', 'e', 'b'];
// 法1 利用临时数组和includes
function func1(arr) {
let tmpArr = [];
for (let i of arr) {
if (!tmpArr.includes(i)) { // 使用 ! 取反
tmpArr.push(i)
}
}
return tmpArr;
}
console.log(func1(arr)); // [ 'a', 'b', 'e' ]
// 法2，利用临时数组和indexOf
function func2(arr) {
let tmpArr = [];
for (let i of arr) {
if (tmpArr.indexOf(i) === -1) { // 使用 ! 取反
tmpArr.push(i)
}
}
return tmpArr;
}
console.log(func2(arr)); // [ 'a', 'b', 'e' ]
// 法3，原地删除，循环数组，拿到当前的元素和它后面的元素比较，如果一样，就删除后面的数字
function func3(arr) {
for(let i = 0; i < arr.length; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[i] === arr[j]) {
arr.splice(j, 1);
// 当删除一个元素后，后面的元素索引都会自动向左移动，可能会导致遗漏的元素
// 所以 j-- 一下，让当前索引再次比较一下
j--;
}
}
}
return arr
}
console.log(func3(arr)); // [ 'a', 'b', 'e' ]
String
在js的基础部分我们说了字符串的基本定义语句，这里我们集中来说说字符串的常用方法。
因为字符串是不可变类型，所以，它的方法都是非破坏性方法。
连接字符串：concat
对多个字符串进行拼接，并且返回新的字符串。
let s1 = 'hello';
let s2 = 'world';
let res;
res = s1.concat(s2); // helloworld
res = s1.concat(s2, 'hahaha', 'heiheihei'); // helloworldhahahaheiheihei
console.log(res);
根据索引获取字符charAt
根据索引下标返回对应的字符，跟str[0]这种类似。
let s1 = 'hello';
let res;
res = s1.charAt(0); // h
res = s1.charAt(4); // o
res = s1.charAt(-1); // 没有索引为-1，所以返回空
res = s1.charAt(10); // 超出索引范围，所以返回空
console.log(res);
根据索引下标返回字符在字符编码表的编码位置：charCodeAt
根据索引下标，返回对应字符在字符编(不仅限于ASCII)码表上的编码位置：
let s1 = 'hello';
let res;
// res = s1.charCodeAt(0); // h --> 104
// res = s1.charCodeAt(4); // o --> 111
// res = s1.charCodeAt(-1); // 没有索引为-1，所以返回 NaN
res = s1.charCodeAt(10); // 超出索引范围，所以返回 NaN
console.log(res);
既然能根据字符返回编码位置，反过来也能根据编码位置对应的字符：
console.log(String.fromCharCode(104)); // h
console.log(String.fromCharCode(111)); // o
console.log(String.fromCharCode(38169)); // 错
判断字符串中是否含有指定子串:indexOf/lastIndexOf
let s1 = 'hello world';
let res;
// 默认从左到右找到第一个符合条件的字符的索引下标,找不到就返回 -1
res = s1.indexOf('o'); // 4
res = s1.indexOf('z'); // -1
// 也可以指定从左到右的起始位置
res = s1.indexOf('o', 6); // 7 从索引下标为6开始往右找
// 也可以找子串在字符串第一次出现的位置
res =s1.indexOf('llo'); // 2
// 从右往左找到一个符合条件的字符的索引下标,找不到就返回 -1
// 其它用法跟indexOf用法一样，这里不在演示
res = s1.lastIndexOf('l'); // 9
console.log(res);
字符串截取：slice
从字符串中截取指定范围的子串，并返回截取结果，并不影响原字符串。
let s1 = 'hello world';
let res;
// 指定截取开始位置和结束位置，注意，尾部截取不到，即不包含尾部
res = s1.slice(0, 2); // he
console.log(res);
以指定字符分割字符串：split
以指定字符分割字符串，并以数组的形式返回分割结果。
let s1 = 'hello world';
let res;
res = s1.split(" "); // [ 'hello', 'world' ]
console.log(res);
let s2 = 'a,b,c,d,e,f';
res = s2.split(","); // [ 'a', 'b', 'c', 'd', 'e', 'f' ]
console.log(res);
返回字符串小写/大写：toLowerCase/toUpperCase
let s1 = 'Hello1W2o3rld';
let res;
// 返回字符串的大写字母小写结果
res = s1.toLowerCase(); // hello1w2o3rld
// 返回字符串的小写字母大写结果
res = s1.toUpperCase(); // HELLO1W2O3RLD
console.log(res);
去除字符串两边的空格:trim
去空格的方法是新出的，所以兼容性不太好，这点需要注意。
let s1 = ' Hello1 W2o3rld\n';
let res;
// 默认去除字符串两边的空格和\n
res = s1.trim(); // Hello1 W2o3rld
// 仅去除字符串一边的空格或者\n
res = s1.trimEnd();
res = s1.trimStart();
console.log(res);
判断字符以什么开头结尾：startsWith/endsWitch
let s1 = 'Hello1 W2o3rld';
let res;
// 判断字符串是否以指定字符开头
res = s1.startsWith('H'); // true
// 判断字符串是否以指定字符结尾
res = s1.endsWith('d'); // true
console.log(res);
Object
在JavaScript中，对象object类似于Python中的字典。
对象的更新
// 这里主要介绍几种更新形式
// 第一种，就是用一个对象覆盖当前对象
let obj1 = { k1: "v1", k2: "", }
let obj2 = { k2: "v22", k3: "v3", }
// obj2覆盖obj1中的所有键值对
obj1 = {...obj2}
console.log('obj1', obj1) // {k2: 'v22', k3: 'v3'}
console.log('obj2', obj2) // {k2: 'v22', k3: 'v3'}
// 第二种，就是用一个对象更新当前对象，如果key存在，就覆盖其value，如果key不存在，就添加上该键值对
let obj1 = { k1: "v1", k2: "v2", }
let obj2 = { k2: "v22", k3: "v3", k4: {k44: 'v44'}}
// obj2更新obj1
Object.assign(obj1, obj2)
// 缺点是浅拷贝，也就是有嵌套对象时，只会拷贝其内存地址，如果嵌套对象有被修改，则会影响所有的相关对象
obj2.k4.k44 = 'v444'
console.log('obj1', obj1) // {k1: 'v1', k2: 'v22', k3: 'v3', k4: {k44: 'v444'}}
console.log('obj2', obj2) // {k2: 'v22', k3: 'v3', k4: {k44: 'v444'}}
// 第三种，解决上面浅拷贝的问题，那就是深拷贝
<!-- 深拷贝可以用lodash这个三方库来做，用之前先引入 -->
<script src="https://cdn.bootcdn.net/ajax/libs/lodash.js/4.17.21/lodash.js"></script>
<script>
let obj1 = {k1: "v1", k2: "v2",}
let obj2 = {k2: "v22", k3: "v3", k4: {k44: 'v44'}}
// obj2更新obj1
// lodash用的时候，就是_.cloneDeep(obj2)
obj1 = _.cloneDeep(obj2)
// 缺点是浅拷贝，也就是有嵌套对象时，只会拷贝其内存地址，如果嵌套对象有被修改，则会影响所有的相关对象
obj2.k4.k44 = 'v444'
console.log('obj1', obj1) // {k1: 'v1', k2: 'v22', k3: 'v3', k4: {k44: 'v44'}}
console.log('obj2', obj2) // {k2: 'v22', k3: 'v3', k4: {k44: 'v444'}}
</script>
Math
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Math
Math 是一个内置对象，它拥有一些数学常数属性和数学函数方法。Math 不是一个函数对象。我们可以当成工具类来使用。
这里只介绍常用的一些属性和方法，更多的参考上面的连接。
// 圆周率
// console.log(Math.PI); // 3.141592653589793
// 绝对值
// console.log(Math.abs(-10)); // 10
// 向上取整
// console.log(Math.ceil(3.6)); // 4
// 向下取整
// console.log(Math.floor(3.6)); // 3
// 四舍五入
// console.log(Math.round(3.6)); // 4
// console.log(Math.round(3.4)); // 3
// 多个值中求最大
// console.log(Math.max(1, 4, 3)); // 4
// 多个值中求最小
// console.log(Math.min(1, 4, 3)); // 1
// x的y次方
// console.log(Math.pow(2, 3)); // 8
// 平方根
// console.log(Math.sqrt(2)); // 1.4142135623730951
random
// 生成0~1之间的随机数，测试结果来看，不包含0和1
let r;
r = Math.random();
// 生成0~n之间的随机数，包含0和n
// r = Math.round(Math.random() * 5);
// 生成 n~m之间的随机数，包含n和m
function ran(n, m) {
// 下面的式子是推算出来的
return Math.round(Math.random() * (m - n)) + n;
}
// console.log(ran(3, 8));
// 通过随机数进行打乱有序数组
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
arr.sort(function (a, b) {
return Math.random() - Math.random();
});
console.log(arr); // [ 1, 6, 2, 3, 7, 4, 10, 8, 9, 5 ]
Date
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Date
创建一个 JavaScript Date 实例，该实例呈现时间中的某个时刻。Date 对象则基于 Unix Time Stamp，即自1970年1月1日（UTC）起经过的毫秒数。
日期时间
// 当前时间
// let d = new Date(); // Fri Aug 13 2021 20:37:26 GMT+0800 (中国标准时间)
// 指定的日期和时间, 日期字符串格式 ‘月/日/年(4位的年) 时:分:秒’
// let d = new Date('2021-8-8'); // Sun Aug 08 2021 00:00:00 GMT+0800 (中国标准时间)
// let d = new Date('2021/8/8'); // Sun Aug 08 2021 00:00:00 GMT+0800 (中国标准时间)
// let d = new Date('8/8/2021'); // Sun Aug 08 2021 00:00:00 GMT+0800 (中国标准时间)
// let d = new Date('8/8/2021 8:8:8'); // Sun Aug 08 2021 08:08:08 GMT+0800 (中国标准时间)
// console.log(d);
// 获取日期对象的周几，返回0~6，周日~周六
// let d1 = new Date(); // 最新的日期对象
// console.log(d1.getDay()); // 5 周五
// let d2 = new Date('8/8/2018');
// console.log(d2.getDay()); // 3 2018年8月8号是周三
// 返回个数字肯定不太好，比如页面要显示周几或者星期几之类的，就可以巧用数组和索引来处理
// let weekName = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
// console.log(weekName[d1.getDay()]); // 周五
// 获取当前的日期
// let d = new Date();
// console.log(d.getDate()); // 13
// 获取当前的月份,返回值有点特殊
// 返回值是 0~11，1月~12月
// console.log(d.getMonth()); // 7
// console.log(d.getMonth() + 1); // 8 当前月份可以手动加一
// 获取四位的年份
// console.log(d.getFullYear()); // 2021
// 获取时/分/秒
// console.log(d.getHours()); // 20 晚上8点
// console.log(d.getMinutes()); // 54 分
// console.log(d.getSeconds()); // 31 秒
let d = new Date();
// 从1970/1/1 00:00:00 到现在经历的秒数
console.log(d.getTime()); // 1628859658254
// 获取当前的时间戳
console.log(Date.now()); // 1628860267198
解构赋值
新语法，将数组或者对象中的元素和变量一一对应：
// 基础用法
// let [a, b, c] = [1, 2, 3];
// console.log(a, b, c); // 1 2 3
// 其他用法
let [a, b, ...c] = [1, 2, 3, 4, 5, 6, 7];
console.log(a, b, c); // 1 2 [ 3, 4, 5, 6, 7 ]
// 交换位置
let arr = ['a', 'b', 'c'];
[arr[0], arr[1]] = [arr[1], arr[0]];
console.log(arr); // [ 'b', 'a', 'c' ]
// 打散数组,解构赋值
function sum(a, b, c) {
return a + b + c;
}
let arr2 = [1, 2, 3];
console.log(sum(...arr2)); // 6
// 解构赋值在对象中的用法
let obj = {name: '孙悟空', age: 18, gender: "male"};
let {name, age, gender} = obj;
console.log(name, age, gender); // 孙悟空 18 male
