摘要：不是一種狀態，而是一種語法上的便利。方法方法返回一個以給定值掉的對象。它的作用是為實例添加狀態改變時的回調函數。

A promise represents the eventual result of an asynchronous operation. The primary way of interacting with a promise is through its then method, which registers callbacks to receive either a promise"s eventual value or the reason why the promise cannot be fulfilled.Promises/A+

Promise實際是一個狀態機，從后面需要用到的狀態開始實現Promise.

var PENDING = 0;
var FULFILLED = 1;
var REJECTED = 2;
function Promise() {
    //存儲三種狀態：PENDING, FULFILLED, REJECTED.初始狀態是PENDING
    var state = PENDING;
    //存儲結果或者錯誤，一旦FULFILLED 或者 REJECTED
    var value = null;
    //存儲sucess和failure處理函數，綁定在.then和.done
    var handlers = [];
}

下一步，添加兩種過渡狀態fulfilling和rejecting:

var PENDING = 0;
var FULFILLED = 1;
var REJECTED = 2;

function Promise() {
  // store state which can be PENDING, FULFILLED or REJECTED
  var state = PENDING;

  // store value once FULFILLED or REJECTED
  var value = null;

  // store sucess & failure handlers
  var handlers = [];

  function fulfill(result) {
    state = FULFILLED;
    value = result;
  }

  function reject(error) {
    state = REJECTED;
    value = error;
  }
}

上面是兩種初級過渡，下面是更高級的過渡，叫做resolve：

var PENDING = 0;
var FULFILLED = 1;
var REJECTED = 2;

function Promise() {
  // store state which can be PENDING, FULFILLED or REJECTED
  var state = PENDING;

  // store value once FULFILLED or REJECTED
  var value = null;

  // store sucess & failure handlers
  var handlers = [];

  function fulfill(result) {
    state = FULFILLED;
    value = result;
  }

  function reject(error) {
    state = REJECTED;
    value = error;
  }

  function resolve(result) {
    try {
      var then = getThen(result);
      if (then) {
        doResolve(then.bind(result), resolve, reject)
        return
      }
      fulfill(result);
    } catch (e) {
      reject(e);
    }
  }
}

/**
 * Check if a value is a Promise and, if it is,
 * return the `then` method of that promise.
 *
 * @param {Promise|Any} value
 * @return {Function|Null}
 */
function getThen(value) {
  var t = typeof value;
  if (value && (t === "object" || t === "function")) {
    var then = value.then;
    if (typeof then === "function") {
      return then;
    }
  }
  return null;
}

/**
 * Take a potentially misbehaving resolver function and make sure
 * onFulfilled and onRejected are only called once.
 *
 * Makes no guarantees about asynchrony.
 *
 * @param {Function} fn A resolver function that may not be trusted
 * @param {Function} onFulfilled
 * @param {Function} onRejected
 */
function doResolve(fn, onFulfilled, onRejected) {
  var done = false;
  try {
    fn(function (value) {
      if (done) return
      done = true
      onFulfilled(value)
    }, function (reason) {
      if (done) return
      done = true
      onRejected(reason)
    })
  } catch (ex) {
    if (done) return
    done = true
    onRejected(ex)
  }
}

以上代碼的簡單實現看參考：https://github.com/then/promise/blob/master/src/core.js

Promise對象有以下幾種狀態:

pending: 初始狀態, 非 fulfilled 或 rejected.

fulfilled: 成功的操作.(如果promise.then(f),立刻調用f)

rejected: 失敗的操作.(如果promise.then(undefined, r),立刻調用r)

如果一個promise對象處在fulfilled或rejected狀態而不是pending狀態，那么它也可以被稱為settled狀態。你可能也會聽到一個術語resolved，它表示promise對象處于settled狀態，或者promise對象被鎖定在了調用鏈中。settled不是一種狀態，而是一種語法上的便利。

Promise.resolve(value)方法返回一個以給定值resolve掉的Promise對象。但如果這個值是thenable的（就是說帶有then方法），返回的promise會“追隨”這個thenable的對象，接收它的最終狀態（指resolved/rejected/pendding/settled）；否則這個被返回的promise對象會以這個值被fulfilled。

//Example
var p = Promise.resolve([1,2,3]);
p.then(function(v) {
  console.log(v[0]); // 1
});

//Polyfill
Promise.resolve = function (value) {
  return new Promise(function (resolve) {
    resolve(value);
  });
};

Promise.reject(reason)方法返回一個用reason拒絕的Promise.

//Example
Promise.reject(new Error("fail")).then(function(error) {
  // 未被調用
}, function(error) {
  console.log(error); // 堆棧跟蹤
});

//Polyfill
Promise.reject = function (value) {
  return new Promise(function (resolve, reject) {
    reject(value);
  });
};

Promise.race(iterable)方法返回一個promise，這個promise在iterable中的任意一個promise被解決或拒絕后，立刻以相同的解決值被解決或以相同的拒絕原因被拒絕。

//Example
var p1 = new Promise(function(resolve, reject) { 
    setTimeout(resolve, 500, "一"); 
});
var p2 = new Promise(function(resolve, reject) { 
    setTimeout(resolve, 100, "二"); 
});

Promise.race([p1, p2]).then(function(value) {
  console.log(value); // "二"
  // 兩個都解決，但p2更快
});

//Polyfill
Promise.race = function (values) {
  // TODO: this polyfill only supports array-likes
  //       it should support all iterables
  return new Promise(function (resolve, reject) {
    values.forEach(function(value){
      Promise.resolve(value).then(resolve, reject);
    });
  });
};

Promise.all(iterable) 方法返回一個promise，該promise會在iterable參數內的所有promise都被解決后被解決。

//Example
var p1 = new Promise(function(resolve, reject) { 
  setTimeout(resolve, 1000, "one"); 
}); 
var p2 = new Promise(function(resolve, reject) { 
  setTimeout(resolve, 2000, "two"); 
});
var p3 = new Promise(function(resolve, reject) {
  setTimeout(resolve, 3000, "three");
});
var p4 = new Promise(function(resolve, reject) {
  setTimeout(resolve, 4000, "four");
});
var p5 = new Promise(function(resolve, reject) {
  reject("reject");
});

Promise.all([p1, p2, p3, p4, p5]).then(function(value) { 
  console.log(value);
}, function(reason) {
  console.log(reason)   //"reject"
});

//Polyfill
Promise.all = function (arr) {
  // TODO: this polyfill only supports array-likes
  //       it should support all iterables
  var args = Array.prototype.slice.call(arr);

  return new Promise(function (resolve, reject) {
    if (args.length === 0) return resolve([]);
    var remaining = args.length;
    function res(i, val) {
      if (val && (typeof val === "object" || typeof val === "function")) {
        var then = val.then;
        if (typeof then === "function") {
          var p = new Promise(then.bind(val));
          p.then(function (val) {
            res(i, val);
          }, reject);
          return;
        }
      }
      args[i] = val;
      if (--remaining === 0) {
        resolve(args);
      }
    }
    for (var i = 0; i < args.length; i++) {
      res(i, args[i]);
    }
  });
};

Promise實例具有then方法，也就是說，then方法是定義在原型對象Promise.prototype上的。它的作用是為Promise實例添加狀態改變時的回調函數。

//Example
var p1 = new Promise(function(resolve, reject) {
  resolve("Success!");
  // or
  // reject ("Error!");
});

p1.then(function(value) {
  console.log(value); // Success!
}, function(reason) {
  console.log(reason); // Error!
});

等同于調用Promise.prototype.then(undefined, onRejected)

//Example
var p1 = new Promise(function(resolve, reject) {
  resolve("Success");
});

p1.then(function(value) {
  console.log(value); // "Success!"
  throw "oh, no!";
}).catch(function(e) {
  console.log(e); // "oh, no!"
});

//Polyfill
Promise.prototype["catch"] = function (onRejected) {
  return this.then(null, onRejected);
};

MDN Promise
Promise官方文檔
Promise對象
then/promise