基本概念
1 .then方法返回的是另一个新的Promise实例，所以可以使用链式写法。
2 .不要在then的方法里面定义reject的回调函数，即then的第二个参数，总是使用catch方法。
promise
.then(function(data) { //cb
// success
})
.catch(function(err) {
// error
});
//catch方法可以不获前面then方法执行中的错误，如果没有使用catch方法指定错误的回掉函数，promise对象抛出的错误是不会传递到外层代码，也就是会吃掉错误代码
//catch方法返回的还是一个promise对象，因此后面还可以接着调用then方法
自带函数
1 .promise.all():这是一个并行promise,也就是同一时间执行许多的异步操作，所有都执行成功会返回成功，其中一个reject,此时第一个reject的实例的返回值，会传递给p的回掉函数。并不是想像的串行函数，一个一个的值依赖着
顺序调用promise
1 .关键是中间出现reject状态，这个循环可以退出，或者再次请求么？好像不可以啊。。。那这个好像没用啊
2 .reject状态可以获取到了。
3 .再次请求刚才失败的函数，失败的情况再次请求几次，如果成功的情况下继续下面的请求
4 .现在知道了前面的进行到的地方，也知道了出错的地方。先处理错误的地方，多次请求，看这个走不走得通
5 .错误的地方使用节流函数进行请求，总共请求x次，在100ms内，因为超过这些个条件就可以认为这个操作是失败的，整个链一定走不通
6 .节流函数每次都会返回一个timer id，是没办法知道每一次的运算结果的（主要是复用的之前的函数，没法修改那个函数），没法获取到promise的返回值，所以想在这个地方引入全局变量，我只需要改变全局变量即可。https://www.jianshu.com/writer#/notebooks/31190174/notes/37191242/preview，全局变量的优势和劣势
7 .使用类似vuex的全局状态管理，这样就很方便管理了。具体要看下node端有没有这种的工具
8 .我顶你个肺，人家有自己的专业写法。。。这个官方文档在搞事情啊。。不过错误请求那一部分原来的是没有的
9 .错误的部分持续运行，如果返回了正确的值，把返回正确的值传到函数里面，新开一个promise链
10 .如果一直是错的话，那么就返回整体的错误。
function runPromiseInSequence(arr, input) {
return arr.reduce(
(promiseChain, currentFunction) =>{ return promiseChain.then(currentFunction,(error)=>{
console.log('错误了')
console.log(currentFunction)
//现在错误的地方
console.log(promiseChain)
//之前的值
return '-1'
})},
Promise.resolve(input)
//这个是初始值，第一个promise函数
);
}
//第一阶段的代码
//第二阶段：反复进行报错函数的请求，如果出现正确返回则保存结果，停止请求，如果一直运行错误的话，就返回错误的返回
//关键是节流函数和这个结合的不是太好
// 首先是setInterval执行防抖函数，之前只是管函数的执行，从来不管每个函数的返回值是什么，也不管怎么根据每一次返回的值确定下一次是否还循环这个函数。
//其次是每一次的setInterval都会改变那个值，怎么停止自己的定时器，还有要把这个函数包装成一个promise语法结构，就更是难存储数据结构
let status=null;
let statusValue=null;
//如果是数量多了的话，管理起来很麻烦
function p1(a) {
return new Promise((resolve, reject) => {
resolve(a * 1);
});
}
// promise function 2
function p2(a) {
return new Promise((resolve, reject) => {
reject('sdf')
});
}
// function 3 - will be wrapped in a resolved promise by .then()
function f3(a) {
return a * 1;
}
// promise function 4
function p4(a) {
return new Promise((resolve, reject) => {
resolve(a * 1);
});
}
const promiseArr = [p1, p2, f3, p4];
function runPromiseInSequence(arr, input) {
return arr.reduce(
(promiseChain, currentFunction) =>{ return promiseChain.then(currentFunction,(error)=>{
console.log('错误了')
console.log(currentFunction)
//现在错误的地方
console.log(promiseChain)
//之前的值
return '-1'
})},
Promise.resolve(input)
//这个是初始值，第一个promise函数
);
}
// runPromiseInSequence(promiseArr, 10)
// .then(console.log);
//节流函数的思想，一共请求count次，在time时间内，如果这些个请求都失败的话，那么就返回失败。
//这个地方还要在想一下
function throttle(fn,gaptime){
let _lastTime=null;
let isTrue=false;
return function(){
if(!isTrue){
let _nowTime= +new Date()
if(_nowTime-_lastTime>gaptime || !_lastTime){
_lastTime=_nowTime
fn.then(
(value)=>{
isTrue=true
console.log('hahah')
console.log(isTrue)
status=true
statusValue=value
},
(error)=>{
console.log('error')
})
}else{
console.log('正在控制函数触发次数')
return false
}
}else{
return false;
}
}
}
function runOnePromise(fn,count,time){
let timer;
return new Promise(function(resolve,reject){
timer=setInterval(throttle(fn,10000),1000)
setTimeout(function(){
clearInterval(timer)
if(status){
console.log(status)
resolve({
"status":'ok',
"value":statusValue
})
}else{
reject('error')
}
},10000)
})
}
runOnePromise(p2(2)).then((a)=>{
console.log(a)
},(error)=>{
console.log('-----')
console.log('error')
})
