JS - Promise使用详解--摘抄笔记

程序员文章站 2024-01-05 12:56:28

上一篇博客JavaScript动态加载script方式引用百度地图API，Uncaught ReferenceError: BMap is not defined 这篇文章中我接触到一个新的单词：Promise，借此来记录一下它，引用来源：JS - Promise使用详解--摘抄笔记因为现在还不会 ......

上一篇博客javascript动态加载script方式引用百度地图api，uncaught referenceerror: bmap is not defined

这篇文章中我接触到一个新的单词：promise，借此来记录一下它，引用来源：js - promise使用详解--摘抄笔记

因为现在还不会jquery，就只看了原生js部分的内容。

一、promises相关概念

promises 的概念是由 commonjs 小组的成员在 promises/a 规范中提出来的。

1，then()方法介绍

根据 promise/a 规范，promise 是一个对象，只需要 then 这一个方法。then 方法带有如下三个参数：

成功回调
失败回调
前进回调（规范没有要求包括前进回调的实现，但是很多都实现了）。

一个全新的 promise 对象从每个 then 的调用中返回。

2，promise对象状态

promise 对象代表一个异步操作，其不受外界影响，有三种状态：

pending（进行中、未完成的）
resolved（已完成，又称 fulfilled）
rejected（已失败）。

（1）promise 从未完成的状态开始，如果成功它将会是完成态，如果失败将会是失败态。

（2）当一个 promise 移动到完成态，所有注册到它的成功回调将被调用，而且会将成功的结果值传给它。另外，任何注册到 promise 的成功回调，将会在它已经完成以后立即被调用。

（3）同样的，当一个 promise 移动到失败态的时候，它调用的是失败回调而不是成功回调。

（4）对包含前进特性的实现来说，promise 在它离开未完成状态以前的任何时刻，都可以更新它的 progress。当 progress 被更新，所有的前进回调(progress callbacks)会被传递以 progress 的值，并被立即调用。前进回调被以不同于成功和失败回调的方式处理；如果你在一个 progress 更新已经发生以后注册了一个前进回调，新的前进回调只会在它被注册以后被已更新的 progress 调用。

（5）注意：只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。

3，promise/a规范图解

4，目前支持promises/a规范的库

q：可以在nodejs 以及浏览器上工作，与jquery兼容，可以通过消息传递远程对象。
rsvp.js：一个轻量级的库，它提供了组织异步代码的工具。
when.js：体积小巧，使用方便。
nodejs的promise
jquery 1.5：据说是基于“commonjs promises/a”规范
winjs / windows 8 / metro

二、使用promises的优势

1，解决回调地狱（callback hell）问题

（1）有时我们要进行一些相互间有依赖关系的异步操作，比如有多个请求，后一个的请求需要上一次请求的返回结果。过去常规做法只能 callback 层层嵌套，但嵌套层数过多的话就会有 callback hell 问题。比如下面代码，可读性和维护性都很差的。

firstasync(function(data){
    //处理得到的 data 数据
    //....
    secondasync(function(data2){
        //处理得到的 data2 数据
        //....
        thirdasync(function(data3){
              //处理得到的 data3 数据
              //....
        });
    });
});

（2）如果使用 promises 的话，代码就会变得扁平且更可读了。前面提到 then 返回了一个 promise，因此我们可以将 then 的调用不停地串连起来。其中 then 返回的 promise 装载了由调用返回的值。

firstasync()
.then(function(data){
    //处理得到的 data 数据
    //....
    return secondasync();
})
.then(function(data2){
    //处理得到的 data2 数据
    //....
    return thirdasync();
})
.then(function(data3){
    //处理得到的 data3 数据
    //....
});

2，更好地进行错误捕获

多重嵌套 callback 除了会造成上面讲的代码缩进问题，更可怕的是可能会造成无法捕获异常或异常捕获不可控。
（1）比如下面代码我们使用 settimeout 模拟异步操作，在其中抛出了个异常。但由于异步回调中，回调函数的执行栈与原函数分离开，导致外部无法抓住异常。

function fetch(callback) {
    settimeout(() => {
        throw error('请求失败')
    }, 2000)
}
 
try {
    fetch(() => {
        console.log('请求处理') // 永远不会执行
    })
} catch (error) {
    console.log('触发异常', error) // 永远不会执行
}
 
// 程序崩溃
// uncaught error: 请求失败

（2）如果使用 promises 的话，通过 reject 方法把 promise 的状态置为 rejected，这样我们在 then 中就能捕捉到，然后执行“失败”情况的回调。

function fetch(callback) {
    return new promise((resolve, reject) => {
        settimeout(() => {
             reject('请求失败');
        }, 2000)
    })
}
 
 
fetch()
.then(
    function(data){
        console.log('请求处理');
        console.log(data);
    },
    function(reason, data){
        console.log('触发异常');
        console.log(reason);
    }
);

当然我们在 catch 方法中处理 reject 回调也是可以的。

function fetch(callback) {
    return new promise((resolve, reject) => {
        settimeout(() => {
             reject('请求失败');
        }, 2000)
    })
}
 
 
fetch()
.then(
    function(data){
        console.log('请求处理');
        console.log(data);
    }
)
.catch(function(reason){
    console.log('触发异常');
    console.log(reason);
});

第二部分：

js - promise使用详解2（es6中的promise）

2015年6月， es2015（即 ecmascript 6、es6）正式发布。其中 promise 被列为正式规范，成为 es6 中最重要的特性之一。

1，then()方法

简单来讲，then 方法就是把原来的回调写法分离出来，在异步操作执行完后，用链式调用的方式执行回调函数。

而 promise 的优势就在于这个链式调用。我们可以在 then 方法中继续写 promise 对象并返回，然后继续调用 then 来进行回调操作。

（1）下面通过样例作为演示，我们定义做饭、吃饭、洗碗（cook、eat、wash）这三个方法，它们是层层依赖的关系，下一步的的操作需要使用上一部操作的结果。（这里使用 settimeout 模拟异步操作）

//做饭
function cook(){
    console.log('开始做饭。');
    var p = new promise(function(resolve, reject){        //做一些异步操作
        settimeout(function(){
            console.log('做饭完毕！');
            resolve('鸡蛋炒饭');
        }, 1000);
    });
    return p;
}
 
//吃饭
function eat(data){
    console.log('开始吃饭：' + data);
    var p = new promise(function(resolve, reject){        //做一些异步操作
        settimeout(function(){
            console.log('吃饭完毕!');
            resolve('一块碗和一双筷子');
        }, 2000);
    });
    return p;
}
 
function wash(data){
    console.log('开始洗碗：' + data);
    var p = new promise(function(resolve, reject){        //做一些异步操作
        settimeout(function(){
            console.log('洗碗完毕!');
            resolve('干净的碗筷');
        }, 2000);
    });
    return p;
}

（2）使用 then 链式调用这三个方法：

cook()
.then(function(data){
    return eat(data);
})
.then(function(data){
    return wash(data);
})
.then(function(data){
    console.log(data);
});

当然上面代码还可以简化成如下：

cook()
.then(eat)
.then(wash)
.then(function(data){
    console.log(data);
});

（3）运行结果如下：

2，reject()方法

上面样例我们通过 resolve 方法把 promise 的状态置为完成态（resolved），这时 then 方法就能捕捉到变化，并执行“成功”情况的回调。

而 reject 方法就是把 promise 的状态置为已失败（rejected），这时 then 方法执行“失败”情况的回调（then 方法的第二参数）。

（1）下面同样使用一个样例做演示

//做饭
function cook(){
    console.log('开始做饭。');
    var p = new promise(function(resolve, reject){        //做一些异步操作
        settimeout(function(){
            console.log('做饭失败！');
            reject('烧焦的米饭');
        }, 1000);
    });
    return p;
}
 
//吃饭
function eat(data){
    console.log('开始吃饭：' + data);
    var p = new promise(function(resolve, reject){        //做一些异步操作
        settimeout(function(){
            console.log('吃饭完毕!');
            resolve('一块碗和一双筷子');
        }, 2000);
    });
    return p;
}
 
cook()
.then(eat, function(data){
  console.log(data + '没法吃!');
})

运行结果如下：

（2）如果我们只要处理失败的情况可以使用 then(null, ...)，或是使用接下来要讲的 catch 方法。

cook()
.then(null, function(data){
  console.log(data + '没法吃!');
})

3，catch()方法

（1）它可以和 then 的第二个参数一样，用来指定 reject 的回调

cook()
.then(eat)
.catch(function(data){
    console.log(data + '没法吃!');
});

（2）它的另一个作用是，当执行 resolve 的回调（也就是上面 then 中的第一个参数）时，如果抛出异常了（代码出错了），那么也不会报错卡死 js，而是会进到这个 catch 方法中。

//做饭
function cook(){
    console.log('开始做饭。');
    var p = new promise(function(resolve, reject){        //做一些异步操作
        settimeout(function(){
            console.log('做饭完毕！');
            resolve('鸡蛋炒饭');
        }, 1000);
    });
    return p;
}
 
//吃饭
function eat(data){
    console.log('开始吃饭：' + data);
    var p = new promise(function(resolve, reject){        //做一些异步操作
        settimeout(function(){
            console.log('吃饭完毕!');
            resolve('一块碗和一双筷子');
        }, 2000);
    });
    return p;
}
 
cook()
.then(function(data){
    throw new error('米饭被打翻了！');
    eat(data);
})
.catch(function(data){
    console.log(data);
});

运行结果如下：

这种错误的捕获是非常有用的，因为它能够帮助我们在开发中识别代码错误。比如，在一个 then() 方法内部的任意地方，我们做了一个 json.parse() 操作，如果 json 参数不合法那么它就会抛出一个同步错误。用回调的话该错误就会被吞噬掉，但是用 promises 我们可以轻松的在 catch() 方法里处理掉该错误。

（3）还可以添加多个 catch，实现更加精准的异常捕获。

somepromise.then(function() {
 return a();
}).catch(typeerror, function(e) {
 //if a is defined, will end up here because
 //it is a type error to reference property of undefined
}).catch(referenceerror, function(e) {
 //will end up here if a wasn't defined at all
}).catch(function(e) {
 //generic catch-the rest, error wasn't typeerror nor
 //referenceerror
}); 

4，all()方法

promise 的 all 方法提供了并行执行异步操作的能力，并且在所有异步操作执行完后才执行回调。

（1）比如下面代码，两个个异步操作是并行执行的，等到它们都执行完后才会进到 then 里面。同时 all 会把所有异步操作的结果放进一个数组中传给 then。

//切菜
function cutup(){
    console.log('开始切菜。');
    var p = new promise(function(resolve, reject){        //做一些异步操作
        settimeout(function(){
            console.log('切菜完毕！');
            resolve('切好的菜');
        }, 1000);
    });
    return p;
}
 
//烧水
function boil(){
    console.log('开始烧水。');
    var p = new promise(function(resolve, reject){        //做一些异步操作
        settimeout(function(){
            console.log('烧水完毕！');
            resolve('烧好的水');
        }, 1000);
    });
    return p;
}
 
promise
.all([cutup(), boil()])
.then(function(results){
    console.log("准备工作完毕：");
    console.log(results);
});

（2）运行结果如下：

5，race()方法

race 按字面解释，就是赛跑的意思。race 的用法与 all 一样，只不过 all 是等所有异步操作都执行完毕后才执行 then 回调。而 race 的话只要有一个异步操作执行完毕，就立刻执行 then 回调。

注意：其它没有执行完毕的异步操作仍然会继续执行，而不是停止。

（1）这里我们将上面样例的 all 改成 race

promise
.race([cutup(), boil()])
.then(function(results){
    console.log("准备工作完毕：");
    console.log(results);
});

（2）race 使用场景很多。比如我们可以用 race 给某个异步请求设置超时时间，并且在超时后执行相应的操作。

//请求某个图片资源
function requestimg(){
    var p = new promise(function(resolve, reject){
    var img = new image();
    img.onload = function(){
       resolve(img);
    }
    img.src = 'xxxxxx';
    });
    return p;
}
 
//延时函数，用于给请求计时
function timeout(){
    var p = new promise(function(resolve, reject){
        settimeout(function(){
            reject('图片请求超时');
        }, 5000);
    });
    return p;
}
 
promise
.race([requestimg(), timeout()])
.then(function(results){
    console.log(results);
})
.catch(function(reason){
    console.log(reason);
});

上面代码 requestimg 函数异步请求一张图片，timeout 函数是一个延时 5 秒的异步操作。我们将它们一起放在 race 中赛跑。

如果 5 秒内图片请求成功那么便进入 then 方法，执行正常的流程。
如果 5 秒钟图片还未成功返回，那么则进入 catch，报“图片请求超时”的信息。

JS - Promise使用详解--摘抄笔记

一、promises相关概念

1，then()方法介绍

2，promise对象状态

3，promise/a规范图解

4，目前支持promises/a规范的库

二、使用promises的优势

1，解决回调地狱（callback hell）问题

2，更好地进行错误捕获

js - promise使用详解2（es6中的promise）

1，then()方法

2，reject()方法

3，catch()方法

4，all()方法

5，race()方法

JS - Promise使用详解--摘抄笔记

在Node.js中使用AngularJS案例详解

js模态对话框使用方法详解

watch在Vue.js中的使用方法详解

JS中事件委托使用详解

LotusPhp笔记之:Cookie组件的使用详解

node.JS的crypto加密模块使用方法详解(MD5,AES,Hmac,Diffie-Hellman加密)

js的作用域使用详解

文本jquery.dotdotdot.js插件的使用方法详解

iOS学习笔记（十六）——详解数据库操作(使用FMDB)