# Promise

### 重试retry

```
//方式1
function retry(fn,times,delay){
    return new Promise((resolve,reject)=>{
        var attemp = function(){
            fn().resolve(resolve).catch(err=>{
                if(times==0){
                    reject(err)
                }else{
                    times--;
                    setTimeOut(()=>{
                        attemp()
                    },delay)
                }
            })
        }
    })
}

//方式2
function retry(fn,times,delay){
    return new Promise((resolve,reject)=>{
        var attemp = function(){
            fn().then(resolve(),err=>{
                if(times==0){
                    reject(err)
                }else{
                    times--;
                    setTimeOut(()=>{
                        attemp()
                    },delay)
                }
            })
        }
    })
}
```

### Promise

Promise本身是**同步的立即执行函数**， 当在executor中执行resolve或者reject的时候, 此时是异步操作， 会先执行then/catch等，当主栈完成后，才会去调用resolve/reject中存放的方法执行，打印p的时候，是打印的返回结果，一个Promise实例。

```
console.log('script start')
let promise1 = new Promise(function (resolve) {
    console.log('promise1')
    resolve()
    console.log('promise1 end')
}).then(function () {
    console.log('promise2')
})
setTimeout(function(){
    console.log('settimeout')
})
console.log('script end')
// 输出顺序: script start->promise1->promise1 end->script end->promise2->settimeout
```

### 实现一个promise.finally

```
Promise.prototype.finally=function(callback){
    let Fn = this.constructor;
    return this.then(
        value=>Fn.resolve(callback()).then(()=>value),
        reason=>Fn.resolve(callback()).then(()=>{throw reason})
    )
}
```

### Promise.all(\[p1,p2,p3])

> 全部执行完成再执行then函数，适用于多个请求调用返回结果后处理使用。

```
var p1 =new Promise(function(resolve,reject){
    setTimeout(function(){
        resolve(1);
    },0)
});
var p2 = new Promise(function(resolve,reject){
        setTimeout(function(){
            resolve(2);
        },200)
 });
 var p3 = new Promise(function(resolve,reject){
        setTimeout(function(){
            try{
            console.log(XX.BBB);
            }
            catch(exp){
                resolve("error");
            }
        },100)
});
Promise.all([p1, p2, p3]).then(function (results) {
    console.log("success")
     console.log(results);
}).catch(function(r){
    console.log("err");
    console.log(r);
});
```

### Promise.race()

`Promise.race()`方法最初是在 ES6 中引入 Promise 时发布的，这个方法需要一个`iterable`作为参数。

`Promise.race(iterable)` 方法返回一个 promise，一旦迭代器中的某个`promise`解决或拒绝，返回的 promise 就会解决或拒绝。

与`Promise.any()`方法不同，`Promise.race()`方法主要关注 Promise 是否已解决，而不管其被解决还是被拒绝。

```
Promise.prototype.race = function(){
    
}
```