let、const(es6)和var的区别

var：var声明变量存在作用域的提升，变量可以在未声明就调用。变量为undefined。

let: let声明变量是块级作用域，一个{}为一块，不存在作用域提升。只有声明变量后才能使用变量，否则会报错。

const:const 定义的常量是基本数据类型，不能修改。定义的常量要是引用数据类型，就可以修改。因为保存在栈内存的数据是不可以被修改的。而基本数据类型是直接存储在栈内存中的，所以不能被修改。引用数据类型在栈内存中存储的是一个隐式指针，真正的数据存储在隐式指针指向的堆地址，不可被修改的是指针，真正的数据是可变的。

解构赋值

数组的解构赋值:相当于剥皮

let res = [0,1,2,'a'];
console.log(...res); // 0 1 2 a

对象的解构赋值

let res={
   
                name: '张杰',
                chaozuo: function () {
   
                    console.log('张杰'); // 张杰
                },
                dance: function () {
   
                    console.log('18');  // 18
                }
         }
let {
    chaozuo, dance } = res;
chaozuo();
dance();

模版字符串 反引号（``）

标签和标签之间可以直接换行，类似于vue中render函数的作用。
字符串拼接时不用加号，变量直接放在${}中

let name = "张杰";
let age = "18";
let send = `我是${name},我今年${age}` 
console.log(send); // 我是张杰，我今年18

箭头函数

let arr = [1,2,3];
let index = arr.findIndex((item)=>{
   
    return item == 1;
})

当箭头函数没有参数或者有多个参数，要用 () 括起来。
当箭头函数函数体有多行语句，用 {} 包裹起来，表示代码块，当只有一行语句，并且需要返回结果时，可以省略 {} , 结果会自动返回。
当箭头函数要返回对象的时候，为了区分于代码块，要用 () 将对象包裹起来。
箭头函数没有自己的this指向，它指向自己的父级

函数形参默认值

为形参赋默认值，有传实参用实参，没有用默认值

// 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'
    })

简化对象写法

let odj={
   
    name,
    age,
}

扩展运算符

解构赋值的...就是扩展运算符。

Symbol

Symbol 是 ES6 新引入的一种原始数据类型，表示独一无二的值。它是 js 第七种数据类型 是一种类似于字符串的数据类型。

//创建 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类型是键值对的有序列表，而键和值都可以是任意类型。

        // 声明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) //0

Promise

详细内容请看 link

类（class）

ES6 引入了class类这个概念，通过class关键字可以定义类，这就是更符合我们平时所理解的面向对象的语言。
1.简单的类

    //类的声明
    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.类的继承

    //子类继承父类
    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中的一切合法对象的基本操作进行自定义.然后用你自定义的操作去覆盖其对象的基本操作，也就是当一个对象去执行一个基本操作时,其执行的过程和结果是你自定义的,而不是对象的。

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种方法如下:

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等。