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=>{
})