ES6知识点总结

声明变量

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('获取失败');

})