(1) 变量申明不会被晋升，即在变量申明之前无奈应用该变量
(2) 具备部分作用域，即 let 申明的变量只能在对应代码块中应用
(3) 不容许反复申明
const 用于申明一个常量
(1) 变量的申明不会被晋升，即在变量申明之前无奈应用该变量
(2) 不容许反复申明
(3) 具备部分作用域，即 const 申明的变量只能在对应代码块中应用。(4) const 申明的变量在申明的时候就要赋值，并且只能赋值一次，不能批改。
ES6 容许依照肯定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构。解构得实质属于“模式匹配”，只有等号两边得模式雷同，右边得变量就会被赋予对应得值。如果解构不胜利，变量得值就等于 undefined。
等号右边的变量放到中括号外部，匹配右侧数组中的元素。(1) let [a,b,c] = [1,2,3];
console.log(a,b,c);//1,2,3
(2) let [a,b,c,d,e] = [1,2,3,[4,5],6];
console.log(a,b,c,d,e);//1,2,3,[4,5],6
(3) 不齐全解构
let [a,b,c,[d],e] = [1,2,3,[4,5,6],7];
console.log(a,b,c,d,e);//1,2,3,[4],7
(4) 汇合解构 应用... 扩大运算符，用在 = 右边聚合作用，返回一个新数组
let [a, ...b] = [1,2,3];
console.log(a,b);//1,[2,3]
(5) 默认值解构(当匹配值严格等于 undefined 时，默认值失效)
let [a,b,c=6]=[4,5];
console.log(a,b,c);//2,5,6
let [a=1, b=2, c=3] = [];
console.log(a,b,c);//1,2,3
(6) 默认值也能够是函数
function test(){console.log("hello");
}
let [a=test()] = [1];
console.log(a);//1
let [a] = [test()];
console.log(a);//"hello" undefiend
// 产生 undefined 的起因是函数 test 没有返回值。(7) let arr = [1,2,3,4];
let [...a] = arr;
console.log(a===arr);//false
等号右边的变量放到大括号外部，匹配右侧对象中的元素。对象的属性没有秩序，变量名必须与属性同名，能力取到正确的值。(1) let {foo,bar} = {foo:"hello",bar:"world"};
console.log(foo,bar);//helloworld
(2) 如果变量名和属性名不统一，须要重命名
let {foo:baz} = {foo:"hello",baz:"world"};
console.log(baz);//hello
(3) 对象的解构赋值是上面模式的简写，后面属性名前面变量名
let {foo:foo,bar:bar} = {foo:"hello",bar:"world"};
(4) 嵌套构造
let obj = {p:["hello",{y:"world"}]
}
let {p:[a,{y:b}]} = obj;
console.log(a,b);//hello world
(5) 默认值构造
let {x:y=3}={};
console.log(y);//3
面试题：const [a,b,c,...d]=[1,2,3,11,999];
const {e,f,f1,g,...h}={f:4,g:5,i:6,j:7};
console.log(a,b,c,d,e,f1,g,h);//1,2,3,[11,999],undefined,undefined,5,{i:6,j:7}
(1) 能够应用对象解构或者是数组解构，应用数组解构能够获取指定字符；应用对象解构能够获取实例属性办法。let [a,b,c] = "hello";
console.log(a,b,c);//h e l
(2) 将字符串转换为数组
let [...arr] = "hello";
console.log(arr);//["h","e","l","l","o"]
(3) 应用对象解构
let {toString,valueOf,length}="hello";// 相当于把“hello”当成 String 根本包装器类型
console.log(toString,valueOf,length);//[Function: toString] [Function: valueOf] 5
let str = "hello";
let {length, toString} = str;
console.log(length === str.__proto__.length);//false
console.log(toString === str.__proto__.toString);//true
能够获取到数值包装器构造函数原型中指定的办法
let {toString,valueOf} = 10;
console.log(toString,valueOf);//[Function: toString] [Function: valueOf]
能够获取到布尔包装器构造函数原型中指定得办法
let {valueOf} = true;
console.log(valueOf);//[Function: valueOf]
ES6 中规定能够间接在对象中写入变量和函数作为对象的属性和办法，此时属性名为变量名，属性值为变量的值。对象简写在将来的应用频率极其高。let name = "zhangsan";
let age = 12;
let gender = "male";
let obj = {
name,
age,
gender
}
(1) Object.is(a,b); 判断 a 和 b 的值是否相等 相似于 ===
console.log(1===1);//true
console.log(Object.is(1,1));//true
console.log(Object.is(1,2));//false
console.log(+0 === -0);//true
console.log(Object.is(+0,-0));//false
console.log(NaN === NaN);//false
console.log(Object.is(NaN,NaN));//true
(2) Object.assign(o, obj); 实现对象深复制、拷贝。第一个参数是指标对象，将 obj 的值复制给 o
let o = {};
let obj {
name:"zhangsan",
age: 12
}
let result = Object.assign(o,obj);// 把 obj 中的内容复制到 o 对象当中，并返回 o 对象
console.log(o);//{name:"zhangsan",age:12}
console.log(result);//{name:"zhangsan",age: 12}
console.log(o === result);//true
Object.assign(o,obj,obj1); 三个参数代表的是合并对象 obj,obj1 到 o 当中并返回 o 对象
let o = {};
let obj = {
name:"zhangsan",
age:12
}
let obj1 = {
name:"lisi",
gender:1
}
let result = Object.assign(o,obj,obj1);
console.log(o);{name:'lisi',age:12,gender:1}
console.log(result);//{name:'lisi',age:12,gender:1}
let result1 = Object.assign(o,obj1,obj);
console.log(result1);//{name:"zhangsan",age:12,gender:1}
(3) Object.getPrototypeOf() 获取原型对象中的办法
let obj = {
name:"",
age:1
}
console.log(obj.__proto__);//[Object: null prototype] {}
console.log(obj.constructor.prototype);//[Object: null prototype] {}
console.log(Object.getPrototypeOf(obj));//[Object: null prototype] {}
(3) 设置原型对象中的办法 Object.setPrototypeOf(obj,obj1) 设置 obj 的原型对象为 obj1
let obj = {
name:"zhangsan",
age:12
}
let obj1 = {gender:"male"}
Object.setPrototypeOf(obj,obj1);
console.log(obj.__proto__);//{gender: "male"}
console.log(obj.constructor.prototype);// [Object: null prototype] {}
console.log(obj.constructor.prototype === obj1);//false
console.log(Object.getPrototypeOf(obj));//{gender: "male"}
(4) Object.keys() 返回对象属性名组成的数组
Object.values() 返回对象属性值组成的数组
Object.entries() 返回对象 [属性名，属性值] 组成的二维数组
let obj = {
name:'terry',
age: 12
}
// 获取所有属性名组成的数组
console.log(Object.keys(obj));//['name', 'age']
// 获取所有属性值组成的数组
console.log(Object.values(obj));// ['terry', 12]
// 获取键值对组成的数组
console.log(Object.entries(obj));//[[ 'name','terry'], ['age', 12]]
(1)... 用在 = 右边，聚合的作用(对象，数组的解构)
let [a, ...b] = [1,2,3,4,5]
console.log(a,b);//1,[2,3,4,5]
(2)... 用在 = 左边，开展（剥离）的作用
let obj1 = {
name:"tom",
age: 20
}
let obj2 = {
...obj1,
gender: "male",
age:18
}
(1) Array.from(); 将类数组对像或其余数据类型 (可迭代的) 转成数组
ES5 将类数组对象或其余数据类型 (可迭代的) 转成数组的办法：Array.prototype.slice.call("类数组对象",0);
ES6 转数组的办法：let arrObj = {
0:"tom",
1: "12",
3: "男",
4: ['jacky','terry']
length:4
}
let arr = Array.from(arrObj);
console.log(arr);//["tom","12","男",['jacky','terry']]
如果将下面代码中的 length 属性去掉，答案会是一个长度为 0 的空数组
而后再把代码改一下，就是具备 length 属性，然而对象的属性名不再是数字类型，而是其余字符串型的，代码如下
let arrObj = {
name:"tom",
age:12,
sex:"男",
friends:['jacky','terry'],
length: 4
}
let arr = Array.from(arrObj);
console.log(arr);//[undefined, undefined, undefined, undefined]
由上可知，要将一个类数组对象转换为一个真正的数组，必须具备以下条件：a. 该类数组对象必须具备 length 属性，用于指定数组的长度。如果没有 length 属性，那嚒转换后的数组是一个空数组。b. 该类数组对象的属性名必须为数值或字符串型的数字。该类数组对象的属性名能够加引号，也能够不加引号。将字符串转换为数组：let str = "hello";
console.log(Array.from(str));//['h','e','l','l','o']
(2) Array.of() 创立数组实例 实参就是数组的元素, 为了解决 new Array(10)传递一个数组，创立 length
创立数组
let arr1 = new Array(1,2,3,4);
console.log(arr1);//[1,2,3,4]
let arr2 = new Array(3);
console.log(arr2);//[<3 empty items>]
let arr3 = Array.of(3);
console.log(arr3);//[3]
(3) Array.prototype.find((item) => {}) find 办法返回第一个满足条件的元素或者 undefined，参数是回调函数
let arr = [1,2,3,2,3];
let result = arr.find((item) => {return item>2;})
console.log(result);//3
(4) Array.prototype.findIndex(); // 参数回调函数
findIndex 返回第一个满足条件的元素的索引或者 -1
let arr = [1,2,3];
let result = arr.findIndex((item) => {return item>2;})
console.log(result);//2
(5) Array.prototype.includes(); includes 是否蕴含某个元素，返回 true/false
let arr = [1,2,3]
console.log(arr.includes(3));//true
(6) Array.prototype.fill() 用来填充数组，批改原数组
let arr = [1,2,3];
let result = arr.fill(4);
console.log(arr,result, arr===result);//[4,4,4] [4,4,4] true
(7) Array.prototype.keys();
Array.prototype.values()
Array.prototype.entries()
//keys,values,entries 变量以后是迭代器对象
let arr = [2,3,4];
let keys = arr.keys();
let values = arr.values();
let entries = arr.entries();
console.log(keys,values,entries);//Object [Array Iterator] {} Objcet [Array Iterator] {} Object [Array Iterator] {}
迭代器实现了 Iterator 接口，只有有实现了 Iterator 接口就能够 for-of 遍历