变量
ES6新增let变量，用来声明变量，用法类似于var，只是声明的变量只在let命令所在的代码块内有效
例1：
for(var j = 0; j < 3 j++) {} console.log(j); // 3
for(let i = 0; i < 3 i++) {} console.log(i); // ReferenceError: i is not defined
例2：
var a = [];
for (var i = 0; i < 10; i++) {
a[i] = function () {
console.log(i);
};
}
a[6](); // 10
var a = [];
for (let i = 0; i < 10; i++) {
a[i] = function () {
console.log(i);
};
}
a[6](); // 6
const也是用于声明变量，表明声明一个常量，一旦声明后，值不能被修改，也就意味着一旦声明就必须进行初始化
例：
const str = 123;
str = 456; // TypeError: Assignment to constant variable.
以上两种声明方式不存在变量提升，也就是只能在声明之后使用，一旦在声明之前使用则会报错，var则存在声明提升
例：
console.log(a); // undefined;
var a = 1;
console.log(b); // 报错
let b = 1;
在一个块级作用域内，同一个变量不能被重复声明
let a = 1;
let a = 2; // 报错
块级作用域
类似于function，在块级作用域外不能访问作用域内的变量
例：
{
let a = 1;
}
变量解构与赋值
准确来说是模式匹配
数组的解构
例1:
let [a, b, c] = [1, 2, 3];
// a 1
// b 2
// c 3
以上是按照顺序进行匹配赋值
例2：
let [a, , b] = [1, 2];
// a 1
// b undefined
例3：设置默认值
let [a = 3, , b = 4] = [1, 2];
// a 1
// b 4
对象的解构
例1：
let {a, b} = {a: 1, b: 2}
// a 1
// b 2
例2：
let {c, b} = {a: 1, b: 2}
// c undefined
// b 2
例3：设置默认值
let {a = 1, b = 2} = {a: 3}
// a 3
// b 2
解构嵌套
例：
let obj = {
p: [
'Hello',
{ y: 'World' }
]
};
let { p: [x, { y }] } = obj;
x // "Hello"
y // "World"
字符串扩展
模板字符串
在es5及之前，想要将几个字符串组合为一个，并且加上参数，必须通过+来拼接
例：
let h = '标题';
let p = '段落';
let result = ''
+ '' + h + ''
+ '
' + p + '
'
+ '';
在es6中新增反引号来标识的模板字符串来简化上面这一过程
例：
let h = '标题';
let p = '段落';
let result = `
${h}
${p}
div`;
上面的${}中可以写任何表达式
例：
let h = '标题';
let p = '段落';
let result = `
${h ? h : '标题不存在'}
${p}
div`;
模板字符串也可以用来执行函数
例：
alert`1`;
以下方法用来表示一个字符串是否在两一个字符串中，支持两个参数
includes 第一个参数表示需要查找的字符串，第二个参数表示查找的起始下标位置
let a = 'abc';
let result1 = a.includes('a'); // true
let result2 = a.includes('d'); // false
let result3 = a.includes('a', 1); // false
startsWith 第一个参数表示需要查找的字符串，第二个参数表示查找的起始下标位置
let a = 'abc';
let result1 = a.startsWith('a'); // true
let result2 = a.startsWith('b'); // false
let result3 = a.startsWith('b', 1); // true
endsWith 第一个参数表示需要查找的字符串，第二个参数表示查找的字符串从前往后的个数，查前多少个的意思，不按照下标来计算
let a = 'abc';
let result1 = a.endsWith('c'); // true
let result2 = a.endsWith('b'); // false
let result3 = a.endsWith('b', 2); // true
数值的方法
Number.isInteger()
判断是否为一个整数
例：
Number.isInteger(2); // true
Number.isInteger(2.1); // false
指数运算符**,指数运算符从右往左计算
例：
let result = 2 ** 3; // 8
let result = 2 ** 3 ** 2; // 512 相当于2 ** (3 ** 2)
函数的扩展
为参数加默认值
例：es5中,为了保证程序的正常运行，我们一般会像下面这样写
function fn(a, b) {
a = a || 123;
b = b || 456;
console.log(a, b); // 1 456
}
fn(1, '');
es6中
例：
function fn(a = 123, b = 456) {
console.log(a, b); // 1 456
}
fn(1, '');
配合解构
function fn({a = 123, b = 456}) {
console.log(a, b); // 1 456
}
fn({a: 1})
箭头函数
例：
let fn1 = id => {
console.log(id); // 1
}
fn1(1);
等同于
let fn2 = function(id) {
console.log(id); // 2
}
fn2(2);
需要返回值时
let fn3 = id => id;
等同于
let fn4 = function(id) {
return id;
}
箭头函数会把箭头后面的{}解析为代码块，如果需要返回一个对象时,需要用小括号包裹
let fn5 = (id1, id2) => ({a: id1 ** 2, b: id2 ** 3});
rest参数
例：
当参数不固定时，想要获取一个参数的集合
es5
function fn1() {
console.log(arguments) // [2, 3, 4] 是一个伪数组
}
fn1(2, 3, 4);
###es6
function fn2(...arg) {
console.log(arg) // [2, 3, 4] 真实的数组
}
fn2(2, 3, 4);
扩展运算符
数组的扩展
例：
扩展到的地方必须有一个宿主，比如对象或者数组
let [...a] = [1, 2, 3];
console.log(a); // [1, 2, 3]
let {...b} = [1, 2, 3];
console.log(b); {0: 1, 1: 2, 2: 3}
例：
let a = [1, 2, 3];
let b = [...a];
console.log(b); // [1, 2, 3];
合并数组
let a = [1, 2, 3];
let b = [4, 5, 6];
let c = [...a, ...b];
console.log(c); // [1, 2, 3, 4, 5, 6]
只能进行浅拷贝
let a = [
{
name: 'li'
}
]
let b = [...a];
console.log(a[0] === b[0]); // true;
b[0].name = 'wang';
console.log(a[0] === b[0]); // true;
我们发现b拷贝于a，但是当b里面子对象的值发生改变后，依然影响到了a，所以慎用
与解构混用
当使用扩展运算符时，把扩展运算符的表达式放在最后一位，否则会报出错误
let a = [1, 2, 3, 4, 5];
let [b, ...c] = a;
console.log(b, c); // 1, [2, 3, 4, 5]
字符串扩展
let a = 'hello';
let [...b] = a;
console.log(b); // ['h', 'e', 'l', 'l', 'o'];
Array.form()方法
用于将类数组的对象转为真实的数组，比如dom
let domList = document.getElementsByTagName('div');
let result = Array.from(domList);
console.log(resule, result instanceof Array); // [div, div, div] true
Array.of()
用于将一组值转为数组
let a = '123';
let b = '456';
let result = Array.of(a, b);
console.log(result); // ['123', '456']
Array.fill()
用于填充一个数组，常常用于数组的初始化，设置默认的初始值
let a = [1, 2, 3].fill(0);
console.log(a); // [0, 0, 0]
还可以接受第二个和第三个参数, 分别代表填充的起始位置和结束位置，不会填充结束位置
let a = [1, 2, 3, 4, 5].fill({name: 'li'}, 2, 3);
console.log(a); // [1, 2, {name: 'li'}, 4, 5]
数组实例的includes方法
相当于indexOf(),用于检测一个元素是否存在于一个数组中，返回布尔值，和indexOf不同的是，它可以检测到NaN的是否存在，而在es5中NaN和任何值都是不相等的
let a = [1, 2, 3, NaN];
console.log(a.includes(2)); // true
console.log(a.includes(NaN)); // true
console.log(a.includes(5)); // false
也可以接受两个参数，第二个参数代表检查的起始位置，默认从0开始
let a = [1, 2, 3, NaN];
console.log(a.includes(2, 0)); // true
console.log(a.includes(2, 2)); // false
console.log(a.includes(NaN， -1));
// true 从倒数的位置查，如果负值绝对值大于数组长度，则从0开始