Promise是异步编程的一种解决方案，从语法上说，Promise是一个对象，从它可以获取异步操作的消息。

Promise的基本用法

Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。它们是两个函数，由JavaScript引擎提供。

• resolve函数的作用是，将Promise对象的状态从“未完成”变为“成功”（即从Pending变为Resolved），在异步操作成功时调用，并将异步操作的结果作为参数传递出去。
• reject函数的作用是，将Promise对象的状态从“未完成”变为“失败”（即从Pending变为Rejected），在异步操作失败时调用，并将异步操作报出的错误作为参数传递出去。
• then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为Resolved时调用，第二个回调函数是Promise对象的状态变为 Reject时调用。

var promise = new Promise(
    //异步执行，Promise对象创建后会被立即执行
    function (resolve,reject) {
        //耗时很长的异步操作
　　if('异步处理成功') {　　
        resolve();    //数据处理成功时调用
　　} else {
        reject();    //数据处理失败时调用
    }
        
    }
)
//Promise实例生成以后，可以用then方法分别指定Resolved状态和Reject状态的回调函数。
promise.then(
    function A() {
        //数据处理成功后执行
    },
    function B() {
        //数据处理失败后执行
    }
)

下面我们举一个简单的例子来模拟一下异步操作成功和异步操作失败函数的运行过程。

console.log('starting');
var promise = new Promise(function(resolve, reject) {  
    setTimeout(function() { 
        console.log("2秒后，我运行了");
        resolve('异步操作成功了');     //
        //reject('异步操作失败了');    //2<br />　　　　 //return 'hello';　　　　　　　//3<br />
    }, 2000) 
    
}).then(function (value) { 
    console.log('异步操作成功后执行我:',value);
},
function (value) {
    console.log('异步操作失败后执行我:',value);
}
)
console.log('我也运行了');

// 上面的代码中1处代码的调用，输出顺序是：
//starting
//我也运行了<br />//2秒后，我运行了
// 异步操作成功后执行我: 异步操作成功了


// 上面的代码中2处代码的调用，输出顺序是：
//starting
//我也运行了<br />//2秒后，我运行了
// 异步操作失败后后执行我: 异步操作失败了<br /><br /><br />//上面的代码中3处代码的调用，输出顺序是：<br />//starting<br />//我也运行了<br />//2秒后，我运行了

<br />知代码3处的return 'hello' 语句在新建的new Promise对象中并没有被当作参数返回给then()函数内.那么会不会返回给promise了呢？我们用一段代码来测试一下<br /><br />

console.log('starting');
var promise = new Promise(function(resolve, reject) {  
    setTimeout(function() { 
        console.log("2秒后，我运行了");
        resolve('异步操作成功了');     //
        //reject('异步操作失败了');    //2
        return 'hello';
    }, 2000) 
    
})
promise.then(function (value) { 
    console.log('异步操作成功后执行我:',value);
},
function (value) {
    console.log('异步操作失败后执行我:',value);
}
)
console.log('我也运行了');
console.log(promise);
setTimeout(function () {
    console.log('5秒后，我执行了');
    console.log(promise);
},5000);


//starting
//我也运行了
//Promise { pending }
　　//[[PromiseStatus]]:"pending"
　　//[[PromiseValue]]:undefined
　　//__proto__:Promise {constructor: , then: , catch: , …}
//2秒后，我运行了
//异步操作成功后执行我: 异步操作成功了
//5秒后，我执行了
//Promise { resolved }
　　//[[PromiseStatus]]:"resolved"
　　//[[PromiseValue]]:"异步操作成功了"
　　//__proto__:Promise {constructor: , then: , catch: , …}

由执行结果可知，变量promise仍然是new Promise对象的一个实例。所以return语句虽然被执行了，但对promise实例不会产生任何影响，相当于不存在。

由上面测试的代码可知，Promise对象有以下两个特点。
（1）对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：Pending（进行中）、Resolved（已完成，又称Fulfilled） 和Rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，

（2）一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从Pending变为Resolved和从Pending变 为Rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果。就算改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。

resolve(value) VS resolve(Promise)

我们会在异步操作成功时调用resolve函数，其作用是将Promise对象的状态从Pending变为Resolved，并将异步操作的结果作为参数传递给then()方法里的第一个函数的形参。

那么传入的参数是值和传入的参数是promise对象时有什么不同呢。我们来看一下例子。

当传入的参数为值时：

var time = new Date();
var promise = new Promise(function(resolve, reject) {  
    setTimeout(function() { 
        console.log("1秒后，我运行了");
        resolve('异步操作成功了');     //
    }, 2000) 
    
}).then(function (value) {
    console.log(value,new Date() - time);
})
//执行的输出结果为：
//2秒后，我运行了
//异步操作成功了 1002

大约过了一秒左右，我们可以看到在resolved状态的回调方法中，我们打印出了上面注释中的内容。我们能够通过resolve方法传递操作的结果，然后在回调方法中使用这些结果。

如果我们在resolve中传入一个Promise实例呢？

var time = new Date();
var promise = new Promise(function(resolve, reject) {  
    setTimeout(function() { 
        console.log("2秒后，我运行了");
        resolve('异步操作成功了');     //
    }, 2000) 
    
})

var promise2 = new Promise(function (resolve,reject) {
    setTimeout(resolve,1000,promise);
}).then(function (value) {
    console.log(value,new Date() - time);
})

//执行后输出的结果为：<br />//2秒后，我运行了
//异步操作成功了 2003

promise2经过了2秒后才打印出来结果。奇怪了，我们不是设置promise2经过1秒后执行吗？

简单说就是因为promise2中的resolve()函数传入了promise对象，此时promise对象的状态决定了promise的状态，同时会把返回值传给promise。

Promise/A+中规定[[Resolve]](promise, x)

2.3.2.如果x是一个promise实例， 则以x的状态作为promise的状态

2.3.2.1.如果x的状态为pending， 那么promise的状态也为pending， 直到x的状态变化而变化。

2.3.2.2.如果x的状态为fulfilled， promise的状态也为fulfilled， 并且以x的不可变值作为promise的不可变值。

2.3.2.3.如果x的状态为rejected， promise的状态也为rejected， 并且以x的不可变原因作为promise的不可变原因。

2.3.4.如果x不是对象或函数，则将promise状态转换为fulfilled并且以x作为promise的不可变值。

Promise.prototype.then()

Promise实例具有then方法，也就是说，then方法是定义在原型对象Promise.prototype上的。它的作用是为Promise实例添加状态改变时的回调函数。 前面说过，then方法的第一个参数是Resolved状态的回调函数，第二个参数（可选）是Rejected状态的回调函数。

then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。

var promise = new Promise(function(resolve, reject) {  
    setTimeout(function() { 
        console.log("2秒后，我运行了");
        resolve('异步操作成功了');     //
    }, 2000) 
    
})
promise.name = 'promise';
console.log('promise:',promise)
var promise2 = promise.then(function (value) {
    console.log(value);
})
promise2.name = 'promise2';
console.log('promise2:',promise2);

// promise:
//     Promise { pending }
//     [[PromiseStatus]]:"pending"
//     [[PromiseValue]]:undefined
//     name:"promise"
//     __proto__:Promise {constructor: , then: , catch: , …}
// promise2:
// Promise { pending }
//     [[PromiseStatus]]:"pending"
//     [[PromiseValue]]:undefined
//     name:"promise2"
//     __proto__:Promise {constructor: , then: , catch: , …}

我们可以知道promise.then()方法执行后返回的是一个新的Promise对象。也就是说上面代码中的promise2是一个Promise对象,它的实现效果和下面的代码是一样的，只不过在then()方法里，JS引擎已经自动帮我们做了。

promise2 = new Promise(function (resolve,reject) {})

既然在then()函数里已经自动帮我实现了一个promise对象，但是我要怎么才能给resolve()或reject()函数传参呢？其实在then()函数里，我们可以用return()的方式来给promise2的resolve()或reject()传参。看一个例子。

//var time = new Date();
var promise = new Promise(function(resolve, reject) {  
    setTimeout(function() { 
        console.log("2秒后，我运行了");
        resolve('异步操作成功了');     //
        //reject('异步操作失败了');    //2
    }, 2000) 
    
})
//console.log('promise:',promise)
var promise2 = promise.then(function (value) {
    console.log(value);
    //resolve('nihao');　　//报错。注意，这里不能写resolve()方法，因为在then函数里是没有resolve方法的
    return (1);　　　　　　　
    //return promise;　　　//也可以return一个promise对象，返回promise对象执行后resolve('参数值')或reject('参数值')内部的参数值<br />　　//如果不写return的话，默认返回的是return undefined 。
})
var promise3 = promise2.then(function (value) {
    console.log('is:',value);
},function (value) {
    console.log('error:',value);
})
promise2.name = 'promise2';
setTimeout(function () {
    console.log(promise2);
},3000);


//2秒后，我运行了
//异步操作成功了
//is: 1
//Promise {resolved}
    //name:"promise2"
    //__proto__:Promise
    //[[PromiseStatus]]:"resolved"
    //[[PromiseValue]]:1

Promise与错误状态处理

.then(null, rejection)，用于指定异步操作发生错误时执行的回调函数。下面我们做一个示例。

var promise = new Promise(function(resolve, reject) {
    setTimeout(function () {
            reject('error');
    },2000);
}).then(null,function(error) {
    console.log('rejected', error)
});
//rejected error

我们知道then()方法执行后返回的也是一个promise对象，因此也可以调用then()方法，但这样的话为了捕获异常信息，我们就需要为每一个then()方法绑定一个.then(null, rejection)。由于Promise对象的错误信息具有“冒泡”性质，错误会一直向后传递，直到被捕获为止。因此Promise为我们提供了一个原型上的函数Promise.prototype.catch()来让我们更方便的 捕获到异常。

我们看一个例子

var promise = new Promise(function(resolve, reject) {
    setTimeout(function () {
            reject('error');
    },2000);
}).then(function(value) {
    console.log('resolve', value);
}).catch(function (error) {
    console.log(error);
})
//运行结果
//error

上面代码中，一共有二个Promise对象：一个由promise产生，一个由then产生。它们之中任何一个抛出的错误，都会被最后一个catch捕获。

但是如果用.then(null, rejection)方法来处理错误信息，我们需要在每一个rejection()方法中返回上一次异常信息的状态，这样当调用的then()方法一多的时候，对会对代码的清晰性和逻辑性造成影响。

所以，一般来说，不要在then方法里面定义Reject状态的回调函数（即then的第二个参数），总是使用catch方法。