ES 的全称是 ECMAScript，它是由 ECMA 国际标准化组织制定的一项脚本语言的标准化规范。现在我们说的ES6，实际上是一个泛指，泛指 ES2015 及后续的版本。
JavaScript语言本身也有如下一些令人不满意的地方，ES6出现就是为了解决这些问题：
- 变量提升特性增加了程序运行时的不可预测性
- 语法过于松散，实现相同的功能，不同的人可能会写出不同的代码
1 - var、let、const
1.1 let：为了替代var关键字
ES6中新增了用于声明变量的关键字let，它的出现主要是为了替代var关键字的。
- 在大括号中使用let关键字声明的变量具有块级作用域，变量只在所处的块级有效
if (true) {
var a = 10; // 使用 var
}
console.log(a) // 10
// 如果是使用 var，即使是在{}外面也能正常访问 a，这显然是不合理的
if (true) {
let a = 10; // 使用 let
}
console.log(a) // 报错：a is not defined
- 使用let关键字声明的变量没有变量提升，这样就可以防止循环变量变成全局变量
for (var i = 0; i < 2; i++) {} // 使用 var
console.log(i); // 2 i变成了全局变量
for (let i = 0; i < 2; i++) {} // 使用 let
console.log(i); // 报错：i is not defined
- 变量必须先声明再使用
console.log(a);
var a = 20; // 使用 var
// 打印：undefined
console.log(a); // 报错：Cannot access 'a' before initialization
let a = 20; // 使用 let
- 使用let关键字声明的变量具有暂时性死区特性
利用let声明的变量会绑定在这个块级作用域，不会受外界的影响
var tmp = 123;
if (true) {
let tmp;
tmp = 'abc';
console.log(tmp); // 'abc'
} // 外面的tmp和{}里面的tmp没有任何关系
console.log(tmp); // 123
1.2 经典面试题
下面代码打印什么？为什么这么打印？
//使用 var
var arr = [];
for (var i = 0; i < 2; i++) {
arr[i] = function () { // 数组中存放函数
console.log(i);
}
}
arr[0](); // 2
arr[1](); // 2
当执行数组里面的函数时，就是执行console.log(i);就是打印i，由于内层作用域没有i，根据变量查找原则，就往外层作用域查找i，由于使用var关键字定义不产生块级作用域，所以外层作用域就是全局作用域，全局作用域中有i=2，所以上面打印2。
此题的关键点在于变量i是全局的，函数执行时输出的都是全局作用域下的i值。
//使用 let
let arr = [];
for (let i = 0; i < 2; i++) {
arr[i] = function () { // 数组中存放函数
console.log(i);
}
}
arr[0](); // 0
arr[1](); // 1
当执行数组里面的函数时，就是console.log(i);就是打印i，由于内层作用域没有i，根据变量查找原则，就往外层作用域查找i，由于使用let关键字定义会产生块级作用域，所以外层作用域就是for循环作用域，每次循环都会产生一个块级作用域，每个块级作用域中的变量都是不同的（分别为i=0，i=1），所以打印 0 1 。
此题的关键点在于每次循环都会产生一个块级作用域，每个块级作用域中的变量都是不同的，函数执行时输出的是循环产生的块级作用域下的i值。
1.3 const：常量
声明常量，常量就是值或者内存地址不能变化的量。
- 具有块级作用域
if (true) {
const a = 10;
}
console.log(a) // a is not defined
- 声明常量时必须赋值
const b; // 报错：Missing initializer in const declaration
- 常量赋值后，值不能修改
//对于基本数据类型，值不能修改
const PI = 3.14;
PI = 100; // Assignment to constant variable.
//对于复杂数据类型，指针指向的内容不能修改
const ary = [100, 200];
ary[0] = 'a';
ary[1] = 'b';
console.log(ary); // ['a', 'b'];
ary = ['a', 'b']; // 报错：Assignment to constant variable.
1.4 var、let、const的区别
- 使用 var 声明的变量，其作用域为该语句所在的函数内，且存在变量提升现象
- 使用 let 声明的变量，其作用域为该语句所在的代码块内，不存在变量提升
- 使用 const 声明的是常量，在后面出现的代码中不能再修改该常量的值
总结：其实let、const就相当于swift中的var、let
2 - 解构赋值
ES6中允许从数组或者对象中提取值，按照对应位置，对变量进行赋值。
- 数组解构允许我们按照一一对应的关系从数组中提取值，然后将值赋值给变量。
let [a, b, c, d, e] = [1, 2, 3]; //等号左边不代表数组，代表结构，里面是变量，等号右边是数组
console.log(a) //1
console.log(b) //2
console.log(c) //3
console.log(d) //undefined
console.log(e) //undefined
// 如果解构不成功，变量的值为undefined
- 对象解构允许我们使用变量的名字匹配对象的属性，如果匹配成功，将对象属性的值赋值给变量。
let person = { name: 'zhangsan', age: 20 };
let {name, age} = person; //等号左边不代表对象，代表结构，里面是变量，等号右边是对象
console.log(name); // 'zhangsan'
console.log(age); // 20
let {name: myName, age: myAge} = person; // myName myAge 属于别名
console.log(myName); // 'zhangsan'
console.log(myAge); // 20
3 - 箭头函数
ES6中新增的快速定义函数的方式，用来简化函数定义语法。
() => {} // ()代表是函数，=>必须要的符号，指向哪一个代码块，{}函数体
const fn = () => {} // 代表把一个箭头函数赋值给fn
- 函数体中只有一句代码，且代码的执行结果就是返回值，可以省略大括号
//传统写法
function sum(num1, num2) {
return num1 + num2;
}
//es6写法
const sum = (num1, num2) => num1 + num2;
- 如果形参只有一个，可以省略小括号
//传统写法
function fn (v) {
return v;
}
//es6写法
const fn = v => v;
- 箭头函数的this
箭头函数不绑定this关键字（也就是箭头函数没有自己的this），箭头函数中的this，指向的是函数定义位置的上下文this。
const obj = { name: '张三'}
function fn () {
console.log(this);// 打印：obj
return () => {
console.log(this); // 打印：obj
}
}
const resFn = fn.call(obj);
resFn();
面试题：下面代码打印什么？为什么这么打印？
var age = 100;
var obj = {
age: 20,
say: () => {
alert(this.age)
}
}
obj.say(); // 打印：100
箭头函数this指向的是函数定义位置的上下文this，而对象是没有作用域的，所以箭头函数虽然在对象中被定义，但是this指向的是全局作用域window，window中有age=100，所以打印100。
- 箭头函数的优点
箭头函数的优点在于解决了this执行环境所造成的一些问题。比如：解决了匿名函数this指向的问题，包括setTimeout和setInterval中使用this所造成的问题。
看完下面例子就明白了。
var obj = {
birth: 1990,
getAge: function() { // 这个是对象方法，所以里面的 this 指向对象
console.log(this); // 打印：obj
var b = this.birth;
var fn = function() { // 这个是普通函数，所以里面的 this 指向window
console.log(this); // 打印：window
console.log(this.birth); // window没有birth，所以打印：undefined
return new Date().getFullYear() - this.birth;
};
return fn();
}
};
console.log(obj.getAge()); // 打印：NaN
上面最后打印NaN，这显然不是我们想要的结果，代码修改如下：
var obj = {
birth: 1990,
getAge: function() { // 这个是对象方法，所以里面的 this 指向对象
var that = this; // 将指向对象的 this 保存下来
var b = this.birth;
var fn = function() { // 这个是普通函数，所以里面的 this 指向window
return new Date().getFullYear() - that.birth;
};
return fn();
}
};
console.log(obj.getAge()); // 打印：31
上面代码，使用var that = this;就可以正确打印了，但是使用var that = this;很麻烦，使用箭头函数就不用使用var that = this;了，代码如下：
var obj = {
birth: 1990,
getAge: function() { // 这个是对象方法，所以里面的 this 指向对象
console.log(this); // 打印：obj
var b = this.birth;
// 箭头函数中的this，指向的是函数定义位置的上下文this，也就是obj对象
var fn = () => new Date().getFullYear() - this.birth;
return fn();
}
};
console.log(obj.getAge()); // 打印：31
4 - 剩余参数
剩余参数语法允许我们将一个不定数量的参数表示为一个数组，这种方式很方便的去声明不知道参数情况下的一个函数。
如下，first是第一个参数，args是其他参数数组，…代表解构，就是把数组中的元素拿出来。
function sum (first, ...args) {
console.log(first); // 10
console.log(args); // [20, 30]
}
sum(10, 20, 30)
剩余参数和数组解构配合使用。
let students = ['wangwu', 'zhangsan', 'lisi'];
let [s1, ...s2] = students;
console.log(s1); // 'wangwu'
console.log(s2); // ['zhangsan', 'lisi']
5 - ES6 的内置对象扩展方法
5.1 Array 的扩展方法
① 展开运算符：...
展开运算符可以将数组或者对象转为用逗号分隔的参数序列。
let ary = [1, 2, 3];
console.log(...ary); // 1 2 3
console.log([...ary]); // [1, 2, 3]
// 虽然console.log(...ary);结果打印是1 2 3，但是将…ary放到数组里面就会自动变成用逗号分隔的参数序列。
- 展开运算符可以应用于合并数组
// 方法一
let ary1 = [1, 2, 3];
let ary2 = [3, 4, 5];
let ary3 = [...ary1, ...ary2];
console.log(...ary1); // 1 2 3
console.log(ary3); // [1, 2, 3, 3, 4, 5]
// 方法二
ary1.push(...ary2);
console.log(ary1); // [1, 2, 3, 3, 4, 5]
- 展开运算符可以将伪数组转换为真正的数组
将伪数组转换成真正的数组之后就可以调用数组的方法了。
let oDivs = document.getElementsByTagName('div'); //返回值就是div的伪数组
oDivs = [...oDivs]; //转换成数组
② 构造函数方法：Array.from()
除了展开运算符，Array.from()也可以将伪数组或可遍历对象转换成真正的数组。
- 如果是伪数组
var oDivs = document.getElementsByTagName('div');
console.log(oDivs) //伪数组
var ary = Array.from(oDivs);
console.log(ary); //数组
打印结果如下：
- 如果是可遍历对象
let arrayLike = { //对象
'0': 'a', // ① 属性名要写对应的索引
'1': 'b',
'2': 'c',
'length': 3 // ② 要指定长度
};
//转成数组
let arr2 = Array.from(arrayLike);
console.log(arr2); // ['a', 'b', 'c']
方法还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组
let arrayLike = { //对象
'0': 1,
'1': 2,
'length': 2
}
let newAry = Array.from(arrayLike, item => item *2);
console.log(newAry); // [2, 4]
注意：如果是对象，那么属性名要写对应的索引，并且一定要指定长度。
③ 实例方法：find()
用于找出第一个符合条件的数组成员，如果没有找到返回undefined，find()的参数是个箭头函数。
let ary = [{
id: 1,
name: '张三'
}, {
id: 2,
name: '李四'
}];
//找数组里面符合条件的值，当数组中元素id等于2的查找出来。注意，只会匹配第一个
let target = ary.find((item, index) => item.id == 2);
console.log(target); // 打印的是李四对象
④ 实例方法：findIndex()
用于找出第一个符合条件的数组成员的位置，如果没有找到返回-1，findIndex()的参数是个箭头函数。
let ary = [1, 5, 10, 15];
let index = ary.findIndex((value, index) => value > 9);
console.log(index); // 2
⑤ 实例方法：includes()
判断某个数组是否包含给定的值，返回布尔值。
[1, 2, 3].includes(2) // true
[1, 2, 3].includes(4) // false
5.2 String 的扩展方法
① 模板字符串
ES6新增的模板字符串，使用反引号定义
let name = `zhangsan`; // 使用反引号定义
- 模板字符串中可以解析变量，格式是：
${变量名}
let name = 'zhangsan';
let sayHello = `hello,my name is ${name}`;
console.log(sayHello); // 打印：hello, my name is zhangsan
- 在模板字符串中可以调用函数，格式是：
${函数调用}
const sayHello = function () {
return '哈哈哈哈 追不到我吧 我就是这么强大';
};
let greet = `${sayHello()} 哈哈哈哈`;
console.log(greet); // 哈哈哈哈 追不到我吧 我就是这么强大 哈哈哈哈
- 模板字符串中可以换行
let result = {
name: 'zhangsan',
age: 20,
sex: '男'
}
let html = ` <div>
<span>${result.name}</span>
<span>${result.age}</span>
<span>${result.sex}</span>
</div> `;
console.log(html);
// 模板字符串可以换行，所以可以把代码写的比较美观，打印如下：
/*
<div>
<span>zhangsan</span>
<span>20</span>
<span>男</span>
</div>
*/
② 实例方法：startsWith() 和 endsWith()
- startsWith()：表示参数字符串是否在原字符串的头部，返回布尔值
- endsWith()：表示参数字符串是否在原字符串的尾部，返回布尔值
let str = 'Hello world!';
str.startsWith('Hello') // true
str.endsWith('!') // true
③ 实例方法：repeat()
repeat方法表示将原字符串重复n次，返回一个新字符串
'x'.repeat(3) // "xxx"
'hello'.repeat(2) // "hellohello"
5.3 Set
ES6 提供了新的数据结构 Set，它类似于数组，但是成员的值都是唯一的，没有重复的值。
使用举例：搜索历史关键字（没有重复的值）
- Set本身是一个构造函数，用来生成 Set 数据结构
const s = new Set();
- Set函数可以接受一个数组作为参数，用来初始化
const set = new Set([1, 2, 3, 4, 4]); // {1, 2, 3, 4}
console.log(set.size); // 4 set.size 可以获取set存储了多少值
- 使用set可以做数组去重，如下：
const s3 = new Set(["a","a","b","b"]);
console.log(s3.size) //2
const ary = [...s3]; //将set通过展开运算符转成数组
console.log(ary) //["a","b"]
① 实例方法
- add(value)：添加某个值，返回 Set 结构本身
- delete(value)：删除某个值，表示删除是否成功，返回一个布尔值
- has(value)：该值是否为 Set 的成员，返回一个布尔值
- clear()：清除所有成员，没有返回值
const s = new Set();
s.add(1).add(2).add(3); // 向set结构中添加值，返回Set结构本身
s.delete(2) // 删除set结构中的2值，返回布尔值
s.has(1) // set结构中是否有1这个值，返回布尔值
s.clear() // 清除set结构中的所有值，没返回值
//注意：删除的是元素的值，不是代表的索引
② 遍历
Set 结构的实例与数组一样，也拥有forEach方法，用于对每个成员执行某种操作，没有返回值。
s.forEach(value => console.log(value))
网友评论