声明变量
let
不能重复声明
块级作用域
可修改let变量的值
，
const
不能重复声明
块级作用域
不能修改const 变量的值
2. 箭头函数
而箭头函数的this指向函数定义时所在的对象
3. 解构赋值
允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构。比如：
let [a, b, c] = [1, 2, 3] // a=1, b=2, c=3
let [d, [e], f] = [1, [2], 3] // 嵌套数组解构 d=1, e=2, f=3
let [g, ...h] = [1, 2, 3] // 数组拆分 g=1, h=[2, 3]
let [i,,j] = [1, 2, 3] // 不连续解构 i=1, j=3
let [k,l] = [1, 2, 3] // 不完全解构 k=1, l=2
对象解构
let {a, b} = {a: 'aaaa', b: 'bbbb'} // a='aaaa' b='bbbb'
let obj = {d: 'aaaa', e: {f: 'bbbb'}}
let {d, e:{f}} = obj // 嵌套解构 d='aaaa' f='bbbb'
let g;
(g = {g: 'aaaa'}) // 以声明变量解构 g='aaaa'
let [h, i, j, k] = 'nice' // 字符串解构 h='n' i='i' j='c' k='e'
变量赋值
const {userName11111, passwordqq} = {userName11111: 'aaaa', passwordqq: 123456}
console.log(userName11111)
console.log(passwordqq)
const [userName1, password1] = ['aaaaxxx', 12345611]
console.log(userName1)
console.log(password1)
5. 数组
s6对数组扩展了4个方法：map、reduce、filter、forEach。
map：原来数组有多少个，map 处理之后还是那么多个。参数：item，index，array
let arr = [12, 35, 56, 79, 56];
let arr1 = arr.map(item => item % 2 === 0 ? '偶' : '奇');
let arr2 = arr.map((item, index) => index + ':' + item);
console.log(arr); // [ 12, 35, 56, 79, 56 ]
console.log(arr1); // [ '偶', '奇', '偶', '奇', '偶' ]
console.log(arr2); // [ '0:12', '1:35', '2:56', '3:79', '4:56' ]
filter: 过滤掉不符合条件的。参数：item，index，array
let arr = [12, 75, 56, 79, 56];
let arr1 = arr.filter(item => item >= 60);
console.log(arr); // [ 12, 75, 56, 79, 56 ]
console.log(arr1); // [ 75, 79 ]
forEach: 遍历。仅仅只是循环用，无返回值，也不会改变原数组。 参数：item，index，array
reduce: 汇总。下面代码中的 tmp 可以理解为前一个值
let arr = [12, 35, 56, 79, 56];
let avg = arr.reduce((tmp, item, index) => {
tmp += item;
if (index === arr.length - 1) tmp /= (index + 1);
return tmp;
})
console.log(avg); // 47.6 也就是这五个数的平均值
（...），它可以将一个数组拆分为参数序列，也可以收集剩下的所有的参数或者数组元素
扩展运算符(…)用于取出参数对象中的所有可遍历属性，拷贝到当前对象之中
// 将一个数组拆分为参数序列
let arr = [1, 2]
function add(a, b) {
return a + b
}
add(...arr)
console.log(add(...arr)) //3
// 收集剩下的所有的参数
function f(a, ...arr) {
console.log(...arr) // 2 3
}
f(1,2,3)
对象的扩展运算符 ...
对象的扩展运算符（...）可以把对象可枚举的属性拆分为键值对序列
用于对象拷贝
let obj1 = { a: 1, b: 2 }
let obj2 = { ...obj1 }
console.log(obj2) // {a:1,b:2}
用于合并对象
let obj1 = { a: 1, b: 2 }
let obj2 = { c: 3, d: 4 }
let obj3 = { a: 100, ...obj1, ...obj2, e: 5, f: 6 } // {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6}
let obj4 = { ...obj1, ...obj2, e: 5, f: 6, a: 100 } // {a: 100, b: 2, c: 3, d: 4, e: 5, f: 6}
(2) Object.assign
Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，拷贝(浅拷贝)到目标对象。
如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。
const target = { a: 1 };
const source1 = {a: 100, b: 2 };
const source2 = { c: 3 };
Object.assign(target, source1, source2);
target // {a:100, b:2, c:3}
面向对象
ES6出来之后，官方提供了面向对象的写法。看代码吧
class Person {
constructor(name, age, address) {
this.name = name;
this.age = age;
this.address = address;
}
introduce() {
console.log(`大家好，我叫${this.name}，今年${this.age}岁，家在${this.address}`);
}
}
class Student extends Person {
constructor(name, age, address, major) {
super(name, age, address);
this.major = major;
}
introduce() {
console.log(`大家好，我叫${this.name}，今年${this.age}岁，家在${this.address}， 专业是${this.major}`);
}
}
let person = new Person('ethan', 24, '包邮区');
person.introduce(); // 大家好，我叫ethan，今年24岁，家在包邮区
let student = new Student('zyc', 18, '南京', '车辆工程');
student.introduce(); // 大家好，我叫zyc，今年18岁，家在南京， 专业是车辆工程
上面定义了一个 Person 类，又定义了一个继承 Person 类的 Student 类，很明显方便了很多。
Promise 主要是用来解决异步操作。
- 同步：串行 简单，方便
- 异步：并行 性能高，体验好
这是 promise 的基本用法
let p = new Promise((resolve, reject) => {
$.ajax({
url: '1.txt',
dataType: 'json',
success(json) {
resolve(json);
},
error(err) {
reject(err);
}
})
});
p.then(json => {
console.log('成功', json);
}, err => {
console.log('获取失败');
})