小猪的博客

iOS开发 Web开发 Geek

0%

Promise大法好

发表于 分类于

Promise简介

Promise是一种解决异步回调问题而发展的编程语言特性，在各种语法中都有支持，比如在JavaScript（ECMAScript 6）／Java（8）／Node.js（0.12）都有原生的支持，而没有原生支持的语言更可以通过第三方框架来简单引入（比如大名鼎鼎的Q）

为什么说异步回调不是好的解决方案

1.Callback Hell

1
2
3
4
5
6
7
8
9
10
11
loadScript("a.js",function(){
    loadScript("b.js",function(){
        loadScript("c.js",function(){
            loadScript("d.js",function(){
                loadScript("e.js",function(){
                    console.log("Fuck to load async files")
                }
            })
        })
    })
})

2.依赖习惯编码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function asyncFunc(callback){
    doSomething(function(err, result){
        if(err){
            callback(err, null);
        }
        callback(null, result);
    })
}

asyncFunc(function(err,result){
    if(err){
        console.error(err);
    }
    console.log(result);
})

anotherAsyncFunc(function(result,err){
    if(result){
        console.log("Fuck why the first is result");
    }
})

还有种种，比如控制流难以书写（多个不同异步任务的条件判断和进度控制），try/catch无法捕获回调异常…………种种原因逼迫人们选择更好的解决方案

Promise的核心

此处以Node.js（v0.12）为例，部分术语可能不同编程语言实现时不同，在JavaScript中，Promise是一个内置对象

友情提示：以下东西仅为装逼，可跳过

  1. 三种状态：
    fullfied：被resolve后的状态
    rejected：被reject后的状态
    pending：初始状态

  2. 两个调用：
    then(onFulfilled, onRejected)：在被resolve后执行onFulfilled函数,而被rejected后执行onRejected函数。并且实际上每次调用Promise的then都会返回一个新的Promise对象
    catch(onRejected)：then(undefined, onRejected)的语法糖，被rejected后执行onRejected函数

  3. 状态转变：
    resolve(value)：语法糖，返回一个立即被fullfied且转变为fullfied状态的Promise对象，等价于：

1
2
3
new Promise(function(resolve){
    resolve(value);
});

reject(value)：语法糖，返回一个立即被resolve且转变为rejected的Promise对象，等价于：

1
2
3
new Promise(function(resolve){
    resolve(value);
});
  1. 控制流：
    Promise.all([promise1, promise2, ...])：当全部Promise对象被resolve时调用then(onFulfilled(value))（value为数组的值）；或者任何一个Promise对象被reject时调用catch(onRejected)
    Promise.race([promise1, promise2, ...])：当任何Promise对象被resolve或者reject时调用then(onFulfilled(value))或者catch(onRejected)

Promise的简单用法

1.Easy Mode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function asyncFunction() {
    if (1 === 1){
        return Promise.resolve("OK");
    }
    else{
        return Promise.reject(new Error("Wrong"));
    }
}

asyncFunction().then(function(val){
    console.log(val);
}).catch(function(err){
    console.error(err);
})

/*
OK
*/

2.Normal Mode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
asyncFunction().then(function(val){
    console.log(val);
    return "First";
}).then(function(val){
    console.log(val);
    return "Second";
}).then(function(val){
    throw new Error("Fuck");
    console.log(val);
}).catch(function(err){
    console.error(err);
})

console.log("Start!");

/*
Start
OK
First
[Error: Fuck]
*/

3.Hard Mode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function anotherAsyncFunction(){
    if (2 != 2){
        return Promise.resolve("OK");
    }
    else{
        return Promise.reject(new Error("Wrong"));
    }
}

Promise.all([asyncFunction(),anotherAsyncFunction()]).then(function(val){
    console.log("All:" + val);
}).catch(function(err){
    console.error("All:" + err);
});

Promise.race([asyncFunction(),anotherAsyncFunction()]).then(function(val){
    console.log("Race:" + val);
}).catch(function(err){
    console.error("Race:" + err);
});

/*
Race:OK
All:Error: Wrong
*/

后话

拥抱Promise，告别Callback，你我值得拥有。连古老的OO圣教——Java大法都拥抱Lambda和Promise，你还在等什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public F.Promise<JsonNode> post(String formData){
   WSRequest request = client.url(url);
   F.Promise<WSResponse> responsePromise = request
           .setContentType("application/x-www-form-urlencoded")
           .post(formData);
   F.Promise<JsonNode> jsonNodePromise = responsePromise.map(value -> {
       return value.asJson();
   });

   responsePromise.onFailure(error -> {
       Logger.error(error);
   });

   return jsonNodePromise;
}