cons和let

1： let的用法和var 类似，但是，let 在let命令所在的代码块内有效。
什么是块级作用域？ 
在{}内的代码就可以被看成是块级作用域
 例：{
      let a = 10;
      var b = 1;
    }
    a // ReferenceError: a is not defined.
    b // 1
 for循环比较适合用let声明
 2： 不存在变量提升
  let的声明变量一定在声明后使用，要不报错。
  // var 的情况
    console.log(foo); // 输出undefined
    var foo = 2;
    // let 的情况
    console.log(bar); // 报错ReferenceError
    let bar = 2;
 3：暂时性死区
 ES6 明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错。总之，在代码块内，使用let命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”（temporal dead zone，简称 TDZ）。
 4：let 不允许重复声明
         // 报错
    function func() {
      let a = 10;
      let a = 1;
    }

const

const只能被定义一次，再次赋值就会报错，就如下面代码这样：
const name = 'lux'
name = 'joe' //再次赋值此时会报错      

模板字符串

我们在以往使用js做大量字符串拼接时，经常会出现这样情况：
var s = 'js'+'html'+'css'+'vue'+'react'+'jquery';
// 再或者这样的
var msg = "Hi \
niaho\
my name is ES6 ${s}"
var s = 'js'+'html'+'css'+'vue'+'react'+'jquery';
// 再或者这样的
var msg = "Hi \
niaho\
my name is ES6 ${s}"

用ES6的模板字符串来简化，变量${}来界定
var s = `js html css vue react jquery`
var msg = `Hi 
niaho
my name is ES6`

函数

 1：函数默认参数
 在ES5中
  function action(num) {
    num = num || 200
    //当传入num时，num为传入的值
    //当没传入参数时，num即有了默认值200
    return num
  }
在ES6中
  // 在定义函数时便初始化了这个参数
  function action(num = 200) {
      console.log(num)
  }
  action() //200
  action(300) //300
 2： 箭头函数    三个特点
 1）：不需要通过function 关键词来创建
 2）：可以省略掉return关键词
 3）：继承当前上下文的this关键词
  //例如：
  [32,320,1,5].map( x =>; x + 1 )
  //等同于：
  [32,320,1,5].map((function(x){
      return x + 1
  }).bind(this))
  在使用箭头函数时，如果只有一个参数，可以省略括号，当大于一个参数时，要：
  var people = (name, age) => {
    const fullName = 'h' + name
    return fullName
  } 
  //如果缺少()或者{}就会报错

 拓展的对象功能
 在ES5中，都是键值对的形式书写
 function people(name, age) {
        return {
            name: name,
            age: age
        };
      }
在ES6 中可以简写：
  function people(name, age) {
      return {
          name,
          age
      };
  }
  2： 给对象添加方法
  ES5： var people = {
      name: 'lux',
      getName: function() {
          console.log(this.name)
      }
  }
  ES6可以省略的function 和冒号
  const people = {
      name: 'lux',
      getName () {
          console.log(this.name)
      }
  }

更方便的数据访问–解构

1： 数组的解构赋值
ES5 只能直接指定值
例：let a = 1;
   let b = 2;
   let c = 3;
ES6 从数组中提取值，按照对应位置，对应量赋值。本质上，这种写法属于模式匹配，只要等号两边的模式相同，左边的变量就会被赋予对应的值。
let [a, b, c] = [1, 2, 3];
如果解构不成功，变量的值等于undefind

解构赋值指定默认值
  let [foo = true] = [];
  foo // true
  let [x, y = 'b'] = ['a']; // x='a', y='b'
  let [x, y = 'b'] = ['a', undefined]; // x='a', y='b'
  注意，ES6 内部使用严格相等运算符（===）

  2：对象的解构赋值
  let { foo, bar } = { foo: "aaa", bar: "bbb" };
  foo // "aaa"
  bar // "bbb"
  数组的元素是按次序排列的，标量的取值由它的位置决定。对象的属性没有次序，变量必须与属性同名，才能取到正确值。
  let { bar, foo } = { foo: "aaa", bar: "bbb" };
  foo // "aaa"
  bar // "bbb"
  let { baz } = { foo: "aaa", bar: "bbb" 
  如果变量名与属性名不一致，必须写成下面这样：
  let { foo: baz } = { foo: 'aaa', bar: 'bbb' };
  baz // "aaa"

  let obj = { first: 'hello', last: 'world' };
  let { first: f, last: l } = obj;
  f // 'hello'
  l // 'world'

Spread Operator 展开运算符

在ES6有三个点的玩法，就是Spread Operator
1：数组合并
const color = ['red', 'yellow']
const colorful = [...color, 'green', 'pink']
console.log(colorful) //[red, yellow, green, pink]
2:合并对象
const alp = { fist: 'a', second: 'b'}
const alphabets = { ...alp, third: 'c' }
console.log(alphabets) //{ "fist": "a", "second": "b", "third": "c"
 组合Object,有重复，右边覆盖左边，（即最后的那个覆盖前面的）
 const first = {
      a: 1,
      b: 2,
      c: 6,
  }
  const second = {
      c: 3,
      d: 4
  }
  const total = { ...first, ...second }
  console.log(total) // { a: 1, b: 2, c: 3, d: 4 }

  用来筛选
  //数组
  const number = [1,2,3,4,5]
  const [first, ...rest] = number  //此时的first解构为了1
  console.log(rest) //2,3,4,5
  //对象
  const user = {
      username: 'lux',
      gender: 'female',
      age: 19,
      address: 'peking'
  }
  const { username, ...rest } = user
  console.log(rest) //{"address": "peking", "age": 19, "gender": "female"

import 和export 分别是导入，导出模块

//全部导入
import people from './example'
//有一种特殊情况，即允许你将整个模块当作单一对象进行导入
//该模块的所有导出都会作为对象的属性存在
import * as example from "./example.js"

//导入部分
import {name, age} from './example'

// 导出默认, 有且只有一个默认
export default App
// 部分导出
export class App extend Component {};
关于导入的时候有无大括号的区别：

1:当用export default people导出时，就用 import people 导入（不带大括号）
2:一个文件里，有且只能有一个export default。但可以有多个export。
3:当用export name 时，就用import { name }导入（记得带上大括号）
4:当一个文件里，既有一个export default people, 又有多个export name 或者 export age时，导入就用 import people, { name, age }
5:当一个文件里出现n多个 export 导出很多模块，导入时除了一个一个导入，也可以用import * as example

promise