ES6实际上是一个泛指，泛指 ES2015 及后续的版本
1，let用于声明变量的关键字
let 声明的变量只在所处于的代码块内有效
if (true) {
let a = 10
}
console.log(a) // a is not defined
2, let 不存在变量提升
console.log(a) // a is not deined
let a = 10
3，let 声明的变量具有暂时性死区特性
var a = 10
if (true) { // 在块级作用域中有 let 关键字声明的变量，这个变量就和这个块级进行绑定
console.log(a)
let a = 20
}
// 报错 Cannot access 'a' before initialization
和let 有关的面试题
var arr = \[\];
for (var i = 0; i < 2; i++) {
arri = function () {
console.log(i)
}
}
arr0 // 2
arr1 // 2
将以上代码中的var i改为let
var arr = \[\];
for (let i = 0; i < 2; i++) {
arri = function () {
console.log(i)
}
}
arr0 // 0
arr1 // 1
2, const
声明的是常量，常量就是值(内存地址)，是不能改变的量
1, 具有块级作用域
if (true) {
const a = 10
}
console.log(a) // a is not defined
2，声明常量时必须赋值
const a // Missing initializer in const declaration
3, 常量赋值后，值不能修改
const a = 10
a = 20
console.log(a) // Assignment to constant variable.
const arr = 1, 2, 3, 4, 5, 6
arr0 = 10
arr1 = 20
console.log(arr)
arr = 'x', 'y', 'z'
console.log(arr)
以上代码, 更改 arr0的值，并没有更改 arr 常量在内存中的存储地址， 而给 arr 重新赋值(arr = 'x', 'y', 'z')却改变了常量在内存中的存储地址。
3, let、const、var区别
1，使用 var 声明的变量，作用域为该语句所在的函数内，且存在变量提升现象
2，使用 let 声明的变量，作用域为该语句所在的代码块重，不存在变量提升
3，使用 const 声明的常量，在后面出现的代码中不能再被修改
4，解构赋值
ES6 允许从数组中提取值，按照对应位置，对变量赋值。对象也可以实现解构
数组解构
let a, b, c, d, e = 1, 2, 3
console.log(a, b, c, d, e) // 1 2 3 undefined undefined
5, 对象解构
let obj = { name: 'Jerry', age: 18 };
let { name, age } = obj;
let { name: uname, age: uage } = obj // uname uage属于别名
console.log(name, age) // Jerry 18
6，箭头函数
箭头函数是用来简化函数定义语法的
// 语法
() => {}
通过我们会把箭头函数赋值给一个变量
const func = () => {}
函数体中只有一句代码的话，并且代码的执行结果就是返回值，我们可以省略大括号
// 传统的函数形式
function func(x, y) {
return x + y
}
// 使用箭头函数的形式
const func = (x, y) => x + y
如果形参只有一个，可以省略小括号
// 传统函数形式
function func (v) {
return v
}
// 箭头函数形式
const func = v => v
箭头函数不绑定 this，箭头函数中没有自己的 this，如果在箭头函数中使用this, this关键字将指向箭头函数定义位置中的 this
function fn() {
console.log(this)
return () => {
// 箭头函数 中的 this 指向的是箭头函数定义区域的 this， 此处箭头函数被定义在 fn 函数的内部，所以箭头函数中的 this 指向的就是 fn这个区域中的this
console.log(this)
}
}
const obj = {
name: 'Jerry'
}
const func = fn.call(obj)
func()
箭头函数面试题：
var age = 100
const obj = {
age: 18,
say: () => {
console.log(this.age) // 此处打印出100， obj 不能产生作用域，所以箭头函数被定义在全局作用域下
}
};
obj.say()
7， 剩余参数
剩余参数允许我们将一个不确定数量的参数表示为一个数组
function func(name, ...args) {
console.log(name) // 1
console.log(args) // 2, 3, 4, 5, 6
}
func(1, 2, 3, 4, 5, 6)
实例：
const sum = (...args) => {
let total = 0;
args.forEach(item => total += item)
return total
}
console.log(sum(10, 20, 30, 40)) // 100
剩余参数配合解构使用：
let person = 'Jerry', 'Lise', 'Tom', 'xiaowang';
let p1, ...p2 = person
console.log(p1) // Jerry
console.log(p2) // 'Lise', 'Tom', 'xiaowang';
8, 扩展运算符
扩展运算符可以将数组或者对象转为用逗号分隔的参数序列
const arr = 1, 2, 3, 4, 5
console.log(...arr) // 1 2 3 4 5
扩展运算应用场景：
可以应用于数组合并
const arr1 = 1, 2, 3
const arr2 = 4, 5, 6
// 方法1:
const arr3 = ...arr1, ...arr2
console.log(arr3) // 1, 2, 3, 4, 5, 6
// 方法2:
arr1.push(...arr2)
console.log(arr1) // 1, 2, 3, 4, 5, 6
扩展运算符可以将 类数组 或可遍历对象转为真正的数组
const divs = document.getElementsByTagName('div');
console.log(divs)
以上就是 伪数组(类数组)，我们把他转为真正的数组：
arduino复制代码const arr = ...divs
console.log(arr)
8, ES6的内置对象扩展
Array的扩展方法
Array的扩展方法1：Array.from()
构造函数方法：Array.from(): 将 类数组 或可遍历的对象转为真正的数组
const obj = {
"0": 100,
'1': 200,
'2': 300,
length: 3
};
const arr = Array.from(obj);
console.log(arr) // 100, 200, 300
Array.from()方法还可以接受第二个参数，作用类似于map方法，用来将每个元素进行处理，将处理后的值放入返回的数组：
const obj = {
"0": 100,
'1': 200,
'2': 300,
length: 3
};
const arr = Array.from(obj, item => item * 2);
console.log(arr) // 200, 400, 600
Array的扩展方法2：find()方法
用于找出第一个符合条件的数组成员，如果没有找到返回 undefined
let arr = [
{
id: 1,
name: 'Jerry'
},
{
id: 2,
name: 'Lise'
}
];
let res = arr.find((item, idx) => item.id === 1)
console.log(res) // {id: 1, name: 'Jerry'}
Array的扩展方法3：findIndex()方法
用于找出第一个符合条件的数组成员的索引，如果没有找到返回 -1
示例1:
let arr = [
{
id: 1,
name: 'Jerry'
},
{
id: 2,
name: 'Lise'
}
];
let res = arr.findIndex((item, idx) => item.id === 1)
console.log(res) // 0
// 示例2:
const arr = 10, 20, 30, 40, 50
const index = arr.findIndex(item => item > 18)
console.log(index) // 1
Array的扩展方法4：includes()方法
表示某个数组是否包含给定的值，返回布尔值
let arr = 'x', 'y', 'z';
console.log(arr.includes('x')) // true
console.log(arr.includes('k')) // false
String的扩展方法
String的扩展方法1：模板字符串(``)
let name = Jerry
console.log(name) // Jerry
模板字符串中可以解析变量
const name = 'Jerry'
const age = 18
const Hi = 我是 ${name}, 今年 ${age}
console.log(Hi) // 模板字符串中的内容可以换行
模板字符串中可以调用函数
j
const func = function () {
return '函数返回内容'
}
const res = ${func()}，哈哈哈～
console.log(res) // 函数返回内容，哈哈哈～
String的扩展方法2：startsWith()、endsWith()
startsWith(): 表示参数字符串是否在原字符串中的头部，返回布尔值
endsWith(): 表示参数字符串是否在原字符串中的尾部，返回布尔值
const str = 'Hello'
console.log(str.startsWith('H')) // true
console.log(str.startsWith('e')) // false
console.log(str.endsWith('e')) // false
console.log(str.endsWith('o')) // true
String的扩展方法3：repeat()
repeat()方法表示将原字符串重复 n 次，返回一个新字符串
const name = 'Jerry'
console.log(name.repeat(3)) // JerryJerryJerry
9, Set
ES6提供的新的数据结构 Set，它类似于数组，但是成员的值都是唯一的，没有重复的值
Set本身是一个构造函数，用来生成 Set数据结构
const s = new Set()
Set函数可以接受数组作为参数，用来初始化
const s = new Set(1, 2, 3, 4, 5, 6, 6, 6)
console.log(s.size)
console.log(s)
Set 应用场景： 数组去重
const arr = new Set('a', 'a', 'b', 'b')
console.log(...arr) // 'a', 'b'
Set实例的方法：
1，add(): 添加，返回 Set 结构本身
2，delete()：删除，返回布尔值，表示删除成功与否
3，has()：返回一个布尔值，表示该值是否为 Set 成员
4，clear()：清除所有成员，没有返回值
const s = new Set();
s.add(1).add(2).add(3) // {1, 2, 3}
s.delete(2) // {1, 3}
s.has(3) // true
s.clear() // {}
Set的实例与数组一样，也拥有forEach 方法，用于对每个成员执行某种操作，没有返回值
s.forEach(value => console.log(value))
示例：
const s = new Set('a', 'b', 'c');
s.forEach(v => console.log(v)) // a b c