JavaScript Promise

 Promise 是 ES6 新增的一个异步解决方案。

function fn(){
    return new Promise((resolve, reject) => {
        var num = parseInt(Math.random() * 10);
        num <= 4 ? resolve(num) : reject(num);
        // 根据条件改变状态
    })
}

fn().then(    // 状态：已完成
    function(data){
        console.log('小于5');
        console.log(data);
    })
.catch(      // 状态：已失败
    function(reason, data){
        console.log('大于4');
        console.log(reason);
    }
);

---

优势1：可以捕获异常 

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

触发异常
请求失败

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

Uncaught Error: 请求失败

异步回调中，回调函数的执行栈与原函数分离开，导致外部无法抓住异常。

---

优势二：避免回调地狱

firstAsync()
.then(function(data){
    //处理得到的 data 数据
    //....
    return secondAsync();
})
.then(function(data2){
    //处理得到的 data2 数据
    //....
    return thirdAsync();
})
.then(function(data3){
    //处理得到的 data3 数据
    //....
});

firstAsync(function(data){
    //处理得到的 data 数据
    //....
    secondAsync(function(data2){
        //处理得到的 data2 数据
        //....
        thirdAsync(function(data3){
              //处理得到的 data3 数据
              //....
        });
    });
});

以众多连续"})"结尾的金字塔结构称为“回调地狱” 。

以上参考：http://www.hangge.com/blog/cache/detail_1635.html