let、const(es6)和var的区别
var：var声明变量存在作用域的提升，变量可以在未声明就调用。变量为undefined。
let: let声明变量是块级作用域，一个{}为一块，不存在作用域提升。只有声明变量后才能使用变量，否则会报错。
const:const 定义的常量是基本数据类型，不能修改。定义的常量要是引用数据类型，就可以修改。因为保存在栈内存的数据是不可以被修改的。而基本数据类型是直接存储在栈内存中的，所以不能被修改。引用数据类型在栈内存中存储的是一个隐式指针，真正的数据存储在隐式指针指向的堆地址，不可被修改的是指针，真正的数据是可变的。
解构赋值
数组的解构赋值:相当于剥皮
javascript
let res = [0,1,2,'a'];
console.log(...res); // 0 1 2 a对象的解构赋值
javascript
let res={
name: '张杰',
chaozuo: function () {
console.log('张杰'); // 张杰
},
dance: function () {
console.log('18'); // 18
}
}
let { chaozuo, dance } = res;
chaozuo();
dance();模版字符串 反引号（``）
标签和标签之间可以直接换行，类似于vue中render函数的作用。
字符串拼接时不用加号，变量直接放在${}中
javascript
let name = "张杰";
let age = "18";
let send = `我是${name},我今年${age}`
console.log(send); // 我是张杰，我今年18箭头函数
javascript
let arr = [1,2,3];
let index = arr.findIndex((item)=>{
return item == 1;
})当箭头函数没有参数或者有多个参数，要用 () 括起来。
当箭头函数函数体有多行语句，用 {} 包裹起来，表示代码块，当只有一行语句，并且需要返回结果时，可以省略 {} , 结果会自动返回。
当箭头函数要返回对象的时候，为了区分于代码块，要用 () 将对象包裹起来。
箭头函数没有自己的this指向，它指向自己的父级
函数形参默认值
为形参赋默认值，有传实参用实参，没有用默认值
javascript
// es6允许给形参赋初始值
// 参数直接设置默认值，位置一般靠后
function add(a,b,c=2) {
console.log(a + b + c);
}
add(1,2)
// 与解构赋值结合使用 结构赋值的先后不影响
function connect({name, age=18, sex}) {
console.log(name);
console.log(age);
console.log(sex);
}
connect({
name:'小宝',
sex: 'man'
})简化对象写法
javascript
let odj={
name,
age,
}扩展运算符
解构赋值的...就是扩展运算符。
Symbol
Symbol 是 ES6 新引入的一种原始数据类型，表示独一无二的值。它是 js 第七种数据类型 是一种类似于字符串的数据类型。
javascript
//创建 Symbol
let h = Symbol()
console.log(a) //Symbol()
console.log(typeof a) //"symbol"
//正常的 Symbol
let h1 = Symbol('张杰')
let h2 = Symbol('张杰')
console.log(h1 === h2) // false
//相等的Symbol ----使用 Symbol.for()
let h3 = Symbol.for('小杰')
let h4 = Symbol.for('小杰')
console.log(h1 === h2) // true集合（set）
Set是es6新增的数据结构，类似于数组，但是成员的值都是唯一的，没有重复的值，我们一般称为集合。项目里面数组去重用到set。
字典（Map）
Map类型是键值对的有序列表，而键和值都可以是任意类型。
javascript
// 声明Map
let m = new Map()
// 1.添加元素(键值对)
m.set('name','小宝')
m.set('age',18)
// 2.获取元素
console.log(m.get(name)) //小宝
// 3.删除元素
m.delete('name')
// 4.获取元素个数
let size = m.size
console.log(size) //1
// 5.检测是否包含某个元素
console.log(m.has('age')); //true
// 6.清空Map
m.clear()
console.log(m) //0Promise
http://t.csdn.cn/2B9Gp请看Promise详解
类（class）
ES6 引入了class类这个概念，通过class关键字可以定义类，这就是更符合我们平时所理解的面向对象的语言。
1.简单的类
javascript
//类的声明
class Phone {
//构造方法 不是必须的，但是constructor名字不能修改
constructor(brand, price) {
this.brand = brand;
this.price = price;
}
//声明成员方法
call(someone) {
console.log(`我可以给${someone}打电话`);
}
sendMessage(someone) {
console.log(`我可以给${someone}打电话`);
}
//声明静态成员
static name = '手机';
static change() {
console.log('吃了吗');
}
}2.类的继承
javascript
//子类继承父类
class SmartPhone extends Phone {
//子类的构造方法
constructor(brand,price,screen,pixel) {
//调用父类的构造方法进行初始化 super
super(brand,price);
this.screen = screen;
this.pixel = pixel;
}
//方法声明
playGame() {
console.log('我可以玩游戏');
}
sw() {
console.log('我可以上网');
}
}
// 子类实例化
const onePlus = new SmartPhone('1+', 3999, 6.5, '4800w');
console.log(onePlus);
console.dir(Phone)
console.log(Phone.name);Proxy
Proxy 对象就是可以让你去对JavaScript中的一切合法对象的基本操作进行自定义.然后用你自定义的操作去覆盖其对象的基本操作，也就是当一个对象去执行一个基本操作时,其执行的过程和结果是你自定义的,而不是对象的。
javascript
let p = new Proxy(target, handler);
// target 是你要代理的对象.它可以是JavaScript中的任何合法对象.如: (数组, 对象, 函数等等)
// handler 是你要自定义操作方法的一个集合.
// p 是一个被代理后的新对象,它拥有 target 的一切属性和方法.只不过其行为和结果是在 handler 中自定义的.
let obj = {
a: 1,
b: 2,
}
const p = new Proxy(obj, {
get(target, key, value) {
if (key === 'c') {
return '我是自定义的一个结果';
} else {
return target[key];
}
},
set(target, key, value) {
if (value === 4) {
target[key] = '我是自定义的一个结果';
} else {
target[key] = value;
}
}
})
console.log(obj.a) // 1
console.log(obj.c) // undefined
console.log(p.a) // 1
console.log(p.c) // 我是自定义的一个结果
obj.name = '李白';
console.log(obj.name); // 李白
obj.age = 4;
console.log(obj.age); // 4
p.name = '李白';
console.log(p.name); // 李白
p.age = 4;
console.log(p.age); // 我是自定义的一个结果
// 从上面这段代码中,我可以很清楚的看到 Proxy 对象的作用.即是之前所受的 用于定义基本操作的自定
//义行为 .同样的 get 和 set 操作.没有没代理的对象所得的结果是其JavaScript本身的执行机制运行
//计算后所得到的.而被代理了的对象的结果则是我们自定义的.1.Proxy所能代理的范围--handler
实际上 handler 本身就是ES6所新设计的一个对象.它的作用就是用来 自定义代理对象的各种可代理操作 。它本身一共有13中方法,每种方法都可以代理一种操作.其13种方法如下:
javascript
handler.getPrototypeOf()
// 在读取代理对象的原型时触发该操作，比如在执行 Object.getPrototypeOf(proxy) 时。
handler.setPrototypeOf()
// 在设置代理对象的原型时触发该操作，比如在执行 Object.setPrototypeOf(proxy, null) 时。
handler.isExtensible()
// 在判断一个代理对象是否是可扩展时触发该操作，比如在执行 Object.isExtensible(proxy) 时。
handler.preventExtensions()
// 在让一个代理对象不可扩展时触发该操作，比如在执行 Object.preventExtensions(proxy) 时。
handler.getOwnPropertyDescriptor()
// 在获取代理对象某个属性的属性描述时触发该操作，比如在执行 Object.getOwnPropertyDescriptor(proxy, "foo") 时。
handler.defineProperty()
// 在定义代理对象某个属性时的属性描述时触发该操作，比如在执行 Object.defineProperty(proxy, "foo", {}) 时。
handler.has()
// 在判断代理对象是否拥有某个属性时触发该操作，比如在执行 "foo" in proxy 时。
handler.get()
// 在读取代理对象的某个属性时触发该操作，比如在执行 proxy.foo 时。
handler.set()
// 在给代理对象的某个属性赋值时触发该操作，比如在执行 proxy.foo = 1 时。
handler.deleteProperty()
// 在删除代理对象的某个属性时触发该操作，比如在执行 delete proxy.foo 时。
handler.ownKeys()
// 在获取代理对象的所有属性键时触发该操作，比如在执行 Object.getOwnPropertyNames(proxy) 时。
handler.apply()
// 在调用一个目标对象为函数的代理对象时触发该操作，比如在执行 proxy() 时。
handler.construct()
// 在给一个目标对象为构造函数的代理对象构造实例时触发该操作，比如在执行new proxy() 时。2.proxy的作用
对于代理模式 Proxy 的作用主要体现在三个方面:
1、 拦截和监视外部对对象的访问
2、 降低函数或类的复杂度
3、 在复杂操作前对操作进行校验或对所需资源进行管理
Generator函数
形式上： Generator函数是一个普通的函数，不过相对于普通函数多出了两个特征。一是在function关键字和函数明之间多了'*'号；二是函数内部使用了yield表达式，用于定义Generator函数中的每个状态。
语法上： Generator函数封装了多个内部状态(通过yield表达式定义内部状态)。执行Generator函数时会返回一个遍历器对象(Iterator(迭代器)对象)。也就是说，Generator是遍历器对象生成函数，函数内部封装了多个状态。通过返回的Iterator对象，可以依次遍历(调用next方法)Generator函数的每个内部状态。
调用上： 普通函数在调用之后会立即执行，而Generator函数调用之后不会立即执行，而是会返回遍历器对象(Iterator对象)。通过Iterator对象的next方法来遍历内部yield表达式定义的每一个状态。
generator函数执行后得到一个生成器
Next()方法:每次调用next()方法，内部执行就从函数头部或上一次停下的地方开始执行，直到遇到下一个yield语句为止。
导入导出
根据功能封装模块 通过import导入 然后通过export导出
可以使用 export 导出也可以使用export default导出
新增的数组方法
比如 filter、some、every、reduce等。