ES6相关1

let和const

let和var的区别

相同点：都是定义变量
区别：
    1.是否有变量提升   var有变量提升，let没有
    2.是否能重复定义   var允许重复定义变量，let不允许重复定义
    3.是否有块级作用域  { }
        全局作用域：在函数外部定义的范围
        局部作用域：在函数内部定义的范围
        块级作用域：在{ }大括号中定义范围
    4.let 定义变量
      const 定义常量

let和const的区别

let 定义变量
const 定义常量,是不能修改的，如果要修改，将常量定义成对象的形式，这样，就可以给对象中的属性进行修改

symbol：是ES6新增的基本数据类型

number,string,boolean,null,undefined,symbol(ES6新增)

symbol:定义的值是唯一性

两个symbol类型的值永远不等

例如：
var s1=Symbol()
var s2=Symbol()
s1=== s2
 false

扩展运算符( ... )

扩展运算符（也称展开操作符）两层作用：
1.将数组转换成数据列表 [a,b,c,d]--->a,b,c,d
例如：
var arr1=[666,777,888]
var arr2=['hello','vuejs']
var result=[...arr1,...arr2]
2.将数据列表转换成数组 a,b,c,d--->[a,b,c,d]
3.展开对象
var result={...obj1,...obj2}
或
result=Object.assign({},obj1,obj2)
例如：
function sum1(str,...args) {
  var result=0;
  for(var i=0;i<args.length;i++) {
    result+=args[i]
  }
   return result;
}
sum1('请输入',20,30,40)

class类

定义一个类：
class Person {
   constructor(a,b) {
     //构造器
     this.属性=a
   }
  方法1() {}
  方法2() {}
  方法3() {}
}
继承一个类：
class Child extends Person {
   constructor(a,b) {
     super()  //代表父类
     //构造器
     this.属性=a
   }
  方法1() {}
  方法2() {}
  方法3() {}
}

set和map:

set:理解成是一个不重复的数组 

将set类型的数据转换成数组：
var s=new Set()
Array.from(s)
或[...s]

var s=new Set()
s.add()
s.has()
s.delete()
s.size
例如：数组去重：
var arr=[3,34,23,2,2,23,23,3,34,34,34,45]
[...new Set(arr)]
map:理解成是一个对象,增强了对象key的数据类型，以前只能是字符串，现在对象的属性可以是做任意的数据类型！
{
  "name":'jack',
  '10':'abc',
  'undefined':999
}
var m1=new Map()
m1.set(属性名,值) //设置
m1.get(属性名)  //获取
m1.delete(属性名)  //删除
//遍历Map类型获取所有值
for(var [key,value] of m1) {
  console.log(key)
  console.log(value)
}

Promise：重点

1.用于处理回调地狱的异步解决方案
具体实现：
function waiting() {
    return new Promise((resolve,reject)=>{    
             setTimeout(function() {    
                //console.log(2)
               reject('哈哈')  
            },2000)      
    })
 }
waiting().then(res=>{
   console.log(1)
   console.log('res:',res)
    console.log(3)
}).catch(error=>{
   console.log('error:',error)
})
.then
.catch
.race
.finally
Promise.all([waiting(),waiting2(),waiting3()])
   .then(res=>{
   }).catch(res=>{
})