let與const

let聲明變量相當于var聲明變量。

let注意事項：

• 沒有作用域，不存在變量提升。在代碼塊內(nèi)，只要let定義變量,在這之前使用都是報錯。先定義再使用。（暫存性死區(qū)）
• 同一個作用域里面不能重復定義變量
• for循環(huán)，for循環(huán)里面是父級作用域，里面又一個作用域

for(let i = 0;i<3;i++){
  let i = "aaa";
  console.log(i);//3遍aaa
}

const聲明常量，定義好了不能改變。

• const和let特性一樣的。
• const定義完變量，必須有值，不能后賦值，不能修改。

const a;
a = 5;//報錯

• const 聲明對象，對象里面的屬性可以修改的，因為是引用值。如果使用了Object.freeze(obj)就不能修改了。

const arr = [1,2,3];
arr.push(4);
console.log(arr);[1,2,3,4]

const obj = Object.freeze([1,2,3]);
obj.push(4);
console.log(obj);//報錯

解構(gòu)賦值

按照一定模式，從數(shù)組和對象中提取值，對變量進行賦值，這被稱為解構(gòu)賦值。類似如下的聲明變量并賦值

let [a,b,c] = [1,5,8];
console.log(a,b,c)//1,5,8

let {name,age,sex} = {name:'es6',age:15,sex:'male'}
console.log(name,age,sex)//'es6',15,'male'

let json = {name:'es6',age:15,sex};
 let {name,sex,age} = json;
console.log(name,sex,age)//'es6','male',15

//如果有些沒值，可以給默認值
let [a,b,c='暫無值'] = [1,2];
console.log(a,b,c)//1,2,暫無值

//交換兩個變量的值
let a = 5;
let b = 2;
[a,b] = [b,a];
console.log(a,b)//2,5

注意

• 左右兩邊，結(jié)構(gòu)格式要保持一致
• 解構(gòu)時候可以給默認值，注意null和undefined的區(qū)別

字符串模板

`${變量名}`這就是字符串模板的符號，優(yōu)點是可以隨意換行。

let json={name:'es5',age:15}
let str = `我叫${json.name},我的年齡是${json.age}`
console.log(str)//我叫es6,我的年齡是15

字符串查找

str.includes(查找內(nèi)容)查找字符串
str.startsWith(檢查內(nèi)容)字符串是否以檢查內(nèi)容開頭
str.endsWith(檢查內(nèi)容)字符串是否以檢查內(nèi)容結(jié)尾
str.repeat(次數(shù))字符串重復次數(shù)

//ES5查找字符串
let str = 'apple banana';
if(str.indexOf('apple') != -1){
console.log('存在')
}esle{console.log('不存在')}

//ES6查找字符串
let str = 'apple banana';
console.log(str.includes('apple'))//true

函數(shù)的改變

• 函數(shù)可以直接給默認值

function show(a=1,b=2){return a+b}
console.log(show()) //3
console.log(show(2)) //4
console.log(show(5,4)) //9

• 函數(shù)參數(shù)默認已經(jīng)定義了，不能再使用let、const聲明

function show(a=8){
  let a = 10;//錯誤
  console.log(a)//報錯
}
show();

• 箭頭函數(shù)

() => {
  語句;
  return
}

注意：

• this問題，定義函數(shù)所在的對象，不再是運行時所在的對象
• 箭頭函數(shù)里面沒有arguments，用...來獲取
• 箭頭函數(shù)不能當構(gòu)造函數(shù)
• ES2017規(guī)定了函數(shù)參數(shù)尾部逗號是可以存在了

擴展運算符，rest運算符 ...

//展開數(shù)組
let arr = [1,2,3];
console.log(...arr);//1  2  3
//合并數(shù)組
function show(...a){
  console.log(a);//[1,2,3,4,5]
}
show(1,2,3,4,5)
//剩余數(shù)組
function fun(a,b,...c){
  console.log(a,b);//1,2
  console.log(c);//[3,4,5]
}
fun(1,2,3,4,5)
//復制數(shù)組
let arr = [1,2,3];
let arr1 = [...arr];

數(shù)組

ES5新增的一些循環(huán)：

• 1、for循環(huán)
• 2、while循環(huán)
• 3、arr.forEach()代替普通的for循環(huán)
• 4、arr.map()非常有用，做數(shù)據(jù)交互，映射。正常情況下，需要配合return返回一個新數(shù)組，如果沒有return就相當于forEach一樣。平時用到map，基本就是要有返回值。重新整理數(shù)據(jù)結(jié)構(gòu)

let arr = [
{name:'張三',age:20,sex:'male'},
{name:'李四',age:25,sex:'female'},
{name:'王麻子',age:22,sex:'male'},
]
let newArr = arr.map((item,index,arr) => {
  let json = {};
  json.n = item.name;
  json.a = item.age;
  json.s = item.sex;
 return json;
})
consloe.log(newArry);//處理過后的json數(shù)據(jù)

• 5、arr.filter()過濾，過濾一些不合格的元素，如果回調(diào)函數(shù)返回的是一個true，就留下來

let arr = [
{name:'張三',age:20,sex:'male'},
{name:'李四',age:25,sex:'female'},
{name:'王麻子',age:22,sex:'male'},
]
let newArr = arr.filter((item,index) => {
  return item.sex == 'male';
})

• 6、arr.some()類似查找，數(shù)組里面某一個符合條件返回true。
• 7、arr.every()數(shù)組里面所有元素都符合條件才返回true。

以上3到7的函數(shù)接收兩個參數(shù)，一個回調(diào)函數(shù)和this的指向forEach(fun,this指向)，回調(diào)函數(shù)里面接收三個參數(shù)fun(value,index,arr){}

• 8、arr.reduce() 從左往右求數(shù)組的和，階乘
• 9、arr.reduceRight()從右往左求數(shù)組的和，階乘

let arr = [1,2,3]

以上8和9的方法里面的回調(diào)函數(shù)接收4個參數(shù)fun(prev,cur,index,arr){} 類似于遞歸。

ES6循環(huán)for...of

arr.keys()數(shù)組的下標
arr.entries()數(shù)組的某一項

let arr = [1,2,3,4,5];
for(let val of arr){
  console.log(val)//1 2 3 4 5
}
for(let index of arr.keys()){
  console.log(index)//0 1 2 3 4
}
for(let item of arr.entries()){
  console.log(item)//0:1,1:2,2:3,3:4,4:5
}
for(let [key,val] of arr.entries()){
  console.log(key,val)//0,1  1,2 ...
}

Array.from() 把類數(shù)組對象轉(zhuǎn)成數(shù)組，生成一個新數(shù)組。Array.of()把一組值轉(zhuǎn)成數(shù)組。

function show(){
  let arg = Array.from(arguments);
  console.log(arg);
}
show(1,2,3,4,5,6);

arr.find() 查找，找出第一個符合條件的數(shù)組成員就返回當前數(shù)組值，如果沒找到返回undefined。

arr.findIndex()找的是位置，沒找到返回-1。

arr.fill(填充的東西，開始位置，結(jié)束位置)填充

對象簡潔語法及對象新增

let name = 'es6';
let age = 15;
let json ={
  name, //name:name
  age, //age:age
  show(){//這里一定注意不要寫箭頭函數(shù)，不然this有問題
    return this.name;
  }
/*show:function(){
  return this.name;
  }*/
}
console.log(json.show());//'es6'

Object.is(a,b)用來比較兩個對象是否相等，解決了NaN不相等的問題
Object.assign(目標對象，source1,source2...)用來合并對象,復制一個對象

let json = {a:1};
let json1 = {b:2};
let json2 = {c:3};
let newObj = Object.assign({},json,json1,json2);
console.log(newObj)//{a:1,b:2,c:3}

ES2017新增的

• Object.keys()
• Object.entries()
• Object.values()

Promise

作用：解決異步回調(diào)問題。傳統(tǒng)方式，大部分用回調(diào)函數(shù)，事件。

new Promise(function(resolve,reject){
  //resolve 成功調(diào)用
  //reject 失敗調(diào)用
})

let a = 10;
let promise=new Promise(function(resolve,reject){
  if(a == 10){resolve('成功')}else{reject('失敗')}
})
promise.then(res => {
  console.log(res);
}).catch(err => {
  console.log(err);
}) 

Promise.resolve('aa'):將現(xiàn)有的東西，轉(zhuǎn)成一個Promise對象，resolve狀態(tài)，成功的狀態(tài)。
Promise.reject('aaa'):將現(xiàn)有的東西，轉(zhuǎn)成一個Promise對象，reject狀態(tài)，失敗的狀態(tài)。
Promise.all()打包prosmise對象扔到一個數(shù)組里面，最后返回的還是一個promise對象，必須確保所有的Promise對象都是resolve狀態(tài)。

let p1 = Promise.resolve('a');
let p2 = Promise.resolve('b');
let p3 = Promise.resolve('c');
Promise.all([p1,p2,p3]).then(res =>{
  let [res1,res2,res3] = res;
  console.log(res1,res2,res3);
})

let status = 1;
let login = (resolve,reject) => {
  setTimeout(() => {
    if(status == 1){
        resolve({data:'登錄成功',msg:'111',token:444})
          }else{
              reject('失敗了');
      }
    },2000);
 }
 let info = (resolve,reject) => {
    setTimeout(() => {
        if(status == 1){
            resolve({data:'獲取信息成功',msg:'111',token:444})
          }else{
              reject('失敗了');
            }
    },1000);
 };
new Promise(login).then(res => {
    console.log('登錄成功');
    return new Promise(info);
}).then(res => {
    console.log('獲取信息成功');
    console.log(res);
})