es6 promise总结

网络上关于promise的文章数不胜数，我就不再多说什么，大神们说的都很清楚了
我这个菜鸟就简单的说一点点在promise中的自己踩过的不理解的点 

1，
/* then()中 
同步操作情况下：
renturn出来的值 
是一个带有value的promise 这样才可以继续的链式调用
如果要接到某个值，并且进行链式调用，必须要return*/


function foo(){
    return Promise.resolve(100)
}
undefined
foo().then((v)=>{
    var x= v+100
    return x       //return的是Promise {<resolved>: 200}
}).then((v)=>{
    console.log(v)
    return v+100
})
//log：200
//return：Promise {<resolved>: 300}

2，
/*在异步操作中：
必须明确的return一个promise 最终的结果必须成功或者失败回调 不然下一步的then将无法得到参数，并且一旦在then中异步操作之后，异步将会传染，得不到类似Promise {<resolved>: 200}，只能得到 Promise {<pending>} 但是v还是可以继续传递的，传递v仍然需要return*/
foo().then((v)=>{
    return new Promise((res=>{
            setTimeout(()=>{
                res(v+100)
            })
        }))
}).then((v)=>{
    return v+100   //v等于300 但是return出来的是Promise {<pending>}
}).then((v)=>{
    console.log(v+100)
})
//===========return
Promise {<pending>}


/*总结：如果then里面有异步操作，就return new promise((res,rej)=>{}) 利用res/rej来进行结果的传递，如果是同步操作，必须使用return 传递*/

多种混合情况：
foo().then((v)=>{
    return new Promise((res=>{
            setTimeout(()=>{
                res(v+100) //异步操作，利用res()传递结果
            },3000)
        }))
}).then((v)=>{
    v=v+100
    return v //同步操作，利用return传递结果
}).then((v)=>{
    return new Promise((res)=>{
    setTimeout(()=>{
        res(v+100) //异步操作，利用res()传递结果
        },3000)
    })
}).then((v)=>{
    return v+100  //同步操作，利用return传递结果
}).then((v)=>{
    return new Promise((res)=>{
        setTimeout(()=>{
            res(v+100)  //异步操作，利用res()传递结果
        })
    })
}).then((v)=>{
console.log(v+100)
    return v+100 //同步操作，利用return传递结果
}).then((v)=>{
              //因为没有return 所以下面接到的v是undefind
}).then((v)=>{
    console.log(v)
    return v
})
//=============== 
//undefined


混合error情况:
foo().then((v)=>{
    return new Promise((res=>{
            setTimeout(()=>{
                res(v+100)
            },3000)
        }))
}).then((v)=>{
    v=v+100
    return v
}).then((v)=>{
    return new Promise((res)=>{
    setTimeout(()=>{

        res(v+100)
        },3000)
    })
}).then((v)=>{
    return v+100
}).then((v)=>{
    return new Promise((res)=>{
        setTimeout(()=>{
            res(v+100)
        })
    })
}).then((v)=>{
    return v+100
}).then((v)=>{
    return Promise.reject(v+100) //此处为error回调
}).then((v)=>{
    console.log('this is resolve' v+100) //不会被打印
    return v+100
},(e)=>{
    console.log('this is error',e+100)
    return e+100
}).then((v)=>{
    console.log('this is v' ,v+100)
    return v+100
})
//=================
Promise {<pending>}
VM2190:35 this is error 900
VM2190:38 this is v 1000




/*co 类似async await co.js*/ 
function run(gen){
  var iter=gen();//非常重要！！！！！！！！！生成器函数创造一个迭代器
  (function x(value){
      var gened=iter.next(value)
      if(!gened.done){
        gened.value.then(x)
      }
  })()
}
//promise版本 co.js
function run(gen){
return new Promise(function(resolve){
  var iter=gen()
  (function x(){
    var gened=iter.next(value)
    if(!gened.done){
      gened.value.then(x)
    }else{
      resolve(gened.value)//将最会有个结果以resolve参数形式传出去
    }
  })()

})
}

//非链式的await调用
function foo(a){
  return new Promise((res)=>{
    setTimeout(()=>{
      res(a)
    },1000)
  })
}
async function bar(){
  var a = await foo(1)
  var b = await foo(a+1)
  return Promise.resolve(b+100)//也可以直接返回这个值 等于promis成功的状态 可以用then接
}
//因为是resoblve 所以要用await去接

所有promise之后resoblve()的值只能用await接住

 function foo(a, b) {//获取到异步的数值
  var x = a + b
  return new Promise(function (resolve) {
    setTimeout(() => {//await的是resolve的参数 
       resolve(x)
    }, 1000)
  })
}

//不加async 可以在函数外部通过 await到resolve的参数
//如果要在函数内部使用await 必须加async

function baz(f,ttime){
  return async (...args)=>{
    return new Promise(resolve=>{
      setTimeout(()=>{
       resolve(f(...args))
      },ttime)  
    })
  }
}

//但是如果要得到这个参数可以用await
async function bbb(){
    var x = await foo(100,100)
    return x
}//return 不出来
async function bbb(){
    var x = await foo(100,100)
    var y = x+400
    console.log(y)
}
//可以log出来


var ary=[]//存储promise
function output(i){
  return new Promise(function(resolve){
    setTimeout(()=>{
      console.log(i)
      resolve()
    },1000*i)
  })
}//制造promise
for(i= 0 ; i <=5;i++){
  ary.push(output(i))
}
Promise.all(ary).then(function(){//启动每一个promise
 setTimeout(()=>{console.log(i)})//如果写上1000 就会依次输出 如果换成let就不行了
})//只会返回all中的最后一个数值

function pipe(rs,ws){//流的简单实现
  rs.on('data',(data)=>{
    ws.write(data)
  })
  res.on('end',()=>{
    ws.end()
  })
 return ws 
}

将一个node函数封装成promise的函数

function promiseify(f) {
  return function (...args) {
    return new Promise((resolve, reject) => {
      f(...args, function (e, r) {
        if (e) {
          reject(e)
        } else {
          resolve(r)
        }
      })
    })
  }
}