摘要：異步執行可以用回調函數實現。全成功也可以通過解構數組的方式，將展開賦值?？梢砸来文玫矫總€結果。放棄暫時放棄執行相當于創建了一個對象。代表是否完成，代表函數完成，已經到終點。是因為最終的結果需要在最后的時候返回最終結果

在JavaScript的世界中，所有代碼都是單線程執行的。
由于這個“缺陷”，導致JavaScript的所有網絡操作，瀏覽器事件，都必須是異步執行。異步執行可以用回調函數實現。

1 promise 翻譯過來是 承諾的意思。
異步：操作之間沒啥關系。同時進行多個操作。
同步：同時只能做一件事情。
異步的缺點就是，代碼復雜，一層套一層，如果需要執行很多個異步操作都完成在執行某個事情，那么就要嵌套很多層，代碼可讀性差，不好維護。如：

    // 異步
 ajax("/bannders",function(bannder_data){
     ajax("/hotItems",function(hotItems_data){
         ajax("/slides",function(slides_data){

         }，function(){
             alert("讀取失敗")
         })
     },function(){
         alert("讀取失敗")
     })
 },function(){
     alert("讀取失敗")
 })

同步：代碼簡單 ,寫起來方便

// 同步
    let bannder_data=ajax_async("/bannders")
    let hotItems_data=ajax_async("/hotItems")
    let slides_data=ajax_async("/slides")

可是同步雖然寫法簡單，但是每個步驟需要等待上一個操作結束，所以實際項目中需要的是異步（不等待）的操作。
于是prosime出現了，他的作用就是：

消除異步操作

用同步一樣的方式來書寫異步代碼

prosime是es6自帶的。需要的用prosime的時候，可以直接new出來一個peomise對象。promise里面有一個參數，這個參數是函數，所有的異步操作代碼都寫在這個函數里面。這個函數有兩個參數，一個是resolve（成功），另外一個是reject（失敗）。例如：

var  p=new Promise(function (resolve,reject) {
   異步代碼
   resolve--成功
   reject---失敗
   $.ajax({
       url:"data/arr.txt",
       dataType:"json",
       success(arr){
           resolve(arr)
       },
       error(err){
           reject(err)
       }
   })
})

promise的使用：p里面的then方法的意思是然后呢？就是當peomise對象執行之后有結果了，
之后執行。then里面有兩個參數，都是函數，第一個函數其實就是resolve對應的結果。
第二個函數就是reject對象的結果。

p.then(function(arr){
   console.log("成功了",arr)
},function(err){
   console.log("失敗了",err)
})

var  p1=new Promise(function (resolve,reject) {
   異步代碼
   resolve--成功
   reject---失敗
   $.ajax({
       url:"data/arr.txt",
       dataType:"json",
       success(arr){
           resolve(arr)
       },
       error(err){
           reject(err)
       }
   })
})


var  p2=new Promise(function (resolve,reject) {
   異步代碼
   resolve--成功
   reject---失敗
   $.ajax({
       url:"data/json.txt",
       dataType:"json",
       success(arr){
           resolve(arr)
       },
       error(err){
           reject(err)
       }
   })
})
promie上有一個方法all，就是全都執行完以后，all的參數是一個數組，是所以的promise對象，
之后then方法里面有兩個參數，都是函數，第一個函數其實就是全都成功以后，其函數的參數就是返回所有resolve結果。，第二個函數是只是有一個失敗了。：
Promise.all([p1,p2]).then(function(arr){
   alert("全成功")
   console.log(arr)
   也可以通過解構數組的方式，將arr展開賦值?？梢砸来文玫?每個resolve結果。
   let  [p1,p2]=arr
   console.log(p1)
   console.log(p2)
},function(){
   alert("至少有一個失敗")
})

Promise的二次封裝，createPromise，抽出可變的URL即可。

function createPromise(url) {
    return new Promise(function (resolve, reject) {
        // 異步代碼
        // resolve--成功
        // reject---失敗
        $.ajax({   
            url,//    url:url      json 值和名相同可簡寫，
            dataType: "json",
            success(arr) {
                resolve(arr)
            },
            error(err) {
                reject(err)
            }
        })
    })
}


// promie上有一個方法all，就是全都執行完以后，all的參數是一個數組，是所以的promise對象，
// 之后then方法里面有兩個參數，都是函數，第一個函數其實就是全都成功以后，其函數的參數就是返回所有resolve結果。，第二個函數是只是有一個失敗了。：
Promise.all([createPromise("data/arr.txt"), createPromise("data/json.txt")]).then(function (arr) {
    alert("全成功")
    console.log(arr)
    //    也可以通過解構數組的方式，將arr展開賦值?？梢砸来文玫?每個resolve結果。
    let [p1, p2] = arr
    console.log(p1)
    console.log(p2)
}, function () {
    alert("至少有一個失敗!")
})

Generator函數是一個帶星星函數（星號和function和函數名不能同時連接接口），而且是一個可以暫停的函數。
函數的內部通過yield來推進函數。通過定義yield后面的值來決定返回的value。
函數返回一個遍歷器，這個遍歷器有一個next方法，可以獲取一個對象，這個對象就包含了yield定義好的參數。

    function *show(){
        alert("a")
        yield; //放棄（暫時放棄執行）
        alert("b")
    }
    let genObj=show() //相當于創建了一個generator對象。
    //這個對象里有一個很重要的東西next（），就是下一步，下一步。
    //就是踹一腳走一步。
    genObj.next() //執行一步之后，看到yield之后，就停止執行了。
    //如果想讓alert（’b‘）出來就需要next兩步。
    genObj.next()

普通函數 ----一路到底
generator函數---中間能停

2.1第一個next是廢的，不能傳參。

// yield可以傳參
function *show(){
    alert("a");

    let a=yield;
    alert("b");
    alert(a);
}
let gen=show();
gen.next(12);  //通過yield傳參的時候，第一個next是廢的，傳傳不了，如果想給第一個yield傳參，
//通過函數就可以傳參
gen.next(5);

2.2給第一個yield傳參，就直接通過函數傳參就可以了

    // 給第一個yield傳參，就直接通過函數傳參就可以了。
    function *show(num1,num2){
        alert(`${num1},${num2}`)
        alert("a");
        
        let a=yield;
        alert("b");
        alert(a);
    }
    let gen=show(98,97);
    gen.next(12);  //通過yield傳參的時候，第一個next是廢的，傳傳不了，如果想給第一個yield傳參，
    //通過函數就可以傳參
    gen.next(5);

3.1 done代表是否完成

    function * show (){
        alert("a")
        yield 12;
        alert("b")
    }
    let gen =show()
    let res1=gen.next()
    console.log(res1)// {done:false, value:12} //done 代表是否完成，代表函數沒完成，沒到終點。
    let res2=gen.next()
    console.log(res2) // {done:true, value:undefind} //done 代表是否完成，true代表函數完成，已經到終點。undefind是因為最終的結果需要在
    // generator最后的時候return 返回最終結果

3.2 generator最后的return是返回最終結果

    function * show (){
        alert("a")
        yield 12; //yield返回
        alert("b")
        return 100
    }
    let gen =show()
    let res1=gen.next()
    console.log(res1)// {done:false, value:12} //done 代表是否完成，代表函數沒完成，沒到終點。
    let res2=gen.next()
    console.log(res2) // {done:true, value:100} //done 代表是否完成，true代表函數完成，已經到終點。undefind是因為最終的結果需要在
    // generator最后的時候return 返回最終結果