按我自己的理解说一下promise，就是你执行一个函数，如果他执行成功了，他就执行resolve函数，如果失败了就执行reject函数。
概念：
摘一下阮一峰老师书里的知识点，
- 对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending、fulfilled和rejected。只有异步操作结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。
- 一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从pending变为resolved、从pending变为rejected。只要这两种情况发生，状态就不会再变了，会一直保持这个结果，这时就称为 resolved（已定型）。如果改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。
- Promise也有一些缺点。 首先、无法取消，一旦新建它就会立即执行，无法中途取消。其次，如果不设置回调函数，Promise内部抛出的错误，不会反应到外部。第三，当处于pending状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）。如果某些事件不断地反复发生，一般来说，使用 Stream 模式是比部署Promise更好的选择。
var promise = new Promise(function(resolve, reject) {
// ... some code
if (/* 异步操作成功 */){
resolve(value);
} else {
reject(error);
}
});
promise.then(function(value) {
// success， Promise对象的状态变为resolved时调用
}, function(error) {
// failure，Promise对象的状态变为rejected时调用。【可选】
});这两个函数都接受Promise对象传出的值作为参数。
Promise新建后会立即执行。then方法指定的回调函数，将在当前脚本所有同步任务执行完才会执行，所以resolved最后输出。
let promise = new Promise(function(resolve, reject) {
console.log('Promise');
resolve();
});
promise.then(function() {
console.log('resolved.');
});
console.log('Hi!');
// Promise
// Hi!
// resolved改编了一下老师书中的例子，
function loadImageAsync(url) {
return new Promise(function(resolve, reject) {
var image = new Image();
image.onload = function() {
resolve(image);
};
image.onerror = function() {
reject(new Error('Could not load image at ' + url));
};
image.src = url;
});
}
loadImageAsync('1.png').then((value) => {
alert(value);
}, function (error) {
alert("图片加载失败啦" + error);
});运行结果
解释一下这个例子：loadImageAsync这个函数接受一个图片的url，如果这个图片加载成功就执行resolve函数并将这个图片作为参数传给他，如果失败就执行reject函数，并抛出一个错误，’Could not load image at ’ + url， 我执行回调方法时传入了一个值为‘1.png’的url，当然这个图片在我的文件夹中是不存在，所以肯定加载不出来，所以程序运行结果就是上面那个图，如果我传入一个真实存在的图片的url，结果就是alert出图片信息，看下最后的程序截图
如果调用resolve函数和reject函数时带有参数，那么它们的参数会被传递给回调函数。reject函数的参数通常是Error对象的实例，表示抛出的错误；resolve函数的参数除了正常的值以外，还可能是另一个 Promise 实例，
resolve函数的参数是一个promise实例
var p1 = new Promise(function (resolve, reject) {
setTimeout(() => reject(new Error('fail')), 3000)
})
var p2 = new Promise(function (resolve, reject) {
setTimeout(() => resolve(p1), 1000)
})
p1.catch(function(error) {
alert('error',error);
});
p2
.then(result => console.log(result))
.catch(error => console.log(error));
解释一下，p2的状态在一秒后变为resolve它的参数是p2，所以p2的状态由p1决定，p1状态此时是pending 它在在三秒后状态变为reject，则p2状态为reject，弹出alert同时执行catch语句输出error
resolved 的 Promise 是在本轮事件循环的末尾执行，总是晚于本轮循环的同步任务。
看下面的例子，很好理解，
new Promise((resolve, reject) => {
resolve(1);
console.log(2);
}).then(r => {
console.log(r);
});
// 2
// 1建议：后继操作应该放到then方法里面，而不应该直接写在resolve或reject的后面。所以，最好在它们（resolve，reject）前面加上return语句，这样后面的语句不会执行，就不会有意外。
Promise.prototype.then() then方法的链式写法
then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。
Promise.prototype.catch()
Promise.prototype.catch方法是.then(null, rejection)的别名，
getJSON('/posts.json').then(function(posts) {
// ...
}).catch(function(error) {
// 处理 getJSON 和 前一个回调函数（then）运行时发生的错误
console.log('发生错误！', error);
});如果Promise状态已经变成resolved，再抛出错误是无效的。
var promise = new Promise(function(resolve, reject) {
resolve('ok');
// promise状态已经改变，后面抛出的错误无效
throw new Error('test');
});
promise
.then(function(value) { console.log(value) })
.catch(function(error) { console.log(error) });
// okpromise的错误具有冒泡性质，知道被捕获
建议不在then方法里面定义Reject状态的回调函数（即then的第二个参数），使用catch方法。
promise会吃掉错误，如果没有catch来处理错误，promise错误不会传递到外层。
const test = function() {
return new Promise(function(resolve, reject) {
resolve(x + 2);
});
};
test().then(function() {
console.log('good');
});
setTimeout(() => { console.log(123) }, 2000);
第一个图是Firefox的截图，下面是chrome的，FF没有报错，而是在两秒后输出123， chrome是报错后两秒输出123
catch可以捕获他前面的then方法的错误，但是不能捕获他后面的，catch方法中也可以抛出错误，如果后面还有catch语句就可以捕获这个错误了
Promise.all()
将多个 Promise 实例，包装成一个新的 Promise 实例。
var pros = [1,2,3,4,5,6].map(function (t) {
return new Promise(function (resolve, reject) {
if (t > 3) {
resolve(t);
} else {
reject(new Error('t: ' + t + ' ' + 'hhhhh~'));
}
});
});
var p = Promise.all(pros);
p.then(function (value) {
alert(value);
})
.catch( function (error) {
alert(error);
});
因为产生的第一个实例状态就是reject，所以p的状态就是reject，然后传递给p的回调函数，然后修改一个if条件如下，显然所有实例状态都是resolved，结果如下图
if(t>0)
const p1 = new Promise((resolve, reject) => {
resolve('hello');
})
.then(result => result)
.catch(e => e);
const p2 = new Promise((resolve, reject) => {
throw new Error('我是p2的catch，报错了');
})
.then(result => result);
// .catch(e =>console.log(e));
Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log('ffff' + e));我把老师给p2的catch注释掉，则p2抛出的错误就会被Promise.all（）方法的catch捕获，效果如图，
如果我不注释掉这句，p2的catch会执行，但Promise.all（）的状态就是resolved，不会执行它的catch，效果如下图
Promise.race()
这个和上面介绍的不同之处就是，只要它的实例中有一个状态改变，它的状态就改变，简单点说只要有一个实例状态变为resolved或者rejected，他的状态就相应改变，修改一下上面的例子。
var pros = [1,2,-3,4,5,6].map(function (t) {
return new Promise(function (resolve, reject) {
if (t > 0) { // 改变了这里
resolve(t);
} else {
reject(new Error('t: ' + t + ' ' + 'hhhhh~'));
}
});
});
var p = Promise.race(pros); //改变了这行
p.then(function (value) {
alert(value);
})
.catch( function (error) {
alert(error);
});
上面的例子，虽然不是每个实例都满足if条件，但是它alert（1）； 这就是这两个方法的不同之处。
异同：
- 同： 只要有一个实例状态是rejected，他的状态就是rejected
- 异： Promise.all（）全部实例状态为resolved，它的状态才为resolved，Promise.race（）只要有一个实例状态为resolved，他的状态就是resolved
Promise.resolve（）
将现有对象转为Promise对象
Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))他的方法的参数，
- 参数是一个promise实例，则不做修改返回
- 参数是thenable对象，将他立即转为promise对象，并立即执行thenable的then方法
- 参数是不具有then方法的对象，或者不是对象。 参数是原始值或是不具有then的对象，则返回一个新的promise对象状态为resolved ； 不具有参数，直接返回一个resolved状态的Promise对象。
var p = Promise.resolve('Hello');
// 字符串Hello不属于异步操作（判断方法是字符串对象不具有then方法），
p.then(function (s){
console.log(s)
});
// Hello如果希望得到一个Promise对象，比较方便的方法就是直接调用Promise.resolve方法。
var p = Promise.resolve();
p.then(function () {
// ...
});执行顺序
立即resolve的Promise对象，是在本轮“事件循环”（event loop）的结束时，而不是在下一轮“事件循环”的开始时。
看一下老师这个例子，
setTimeout(function () {
console.log('three');
}, 0);
Promise.resolve().then(function () {
console.log('two');
});
console.log('one');
// one
// two
// three
// setTimeout(fn, 0)在下一轮“事件循环”开始时执行，Promise.resolve()在本轮“事件循环”结束时执行，console.log('one')则是立即执行，因此最先输出。Promise.reject()
与上面介绍的有一点不同就是它的返回值会将它的参数返回给catch，而不是抛出的错
const p = {
then(resolve, reject) {
reject('出错了');
}
};
Promise.reject(p)
.catch(e => {
console.log(e === p)
})
这一章老师提到的done方法。。。感觉自己代码没问题，但是浏览器没反应。
Promise.try（）
不知道或者不想区分，函数f是同步函数还是异步操作，但是想用 Promise 来处理它。因为这样就可以不管f是否包含异步操作，都用then方法指定下一步流程，用catch方法处理f抛出的错误。一般就会采用下面的写法。
Promise.resolve().then(f)缺点，就是如果f是同步函数，那么它会在本轮事件循环的末尾执行。
const f = () => console.log('now');
Promise.resolve().then(f); // Promise 包装后，变成异步执行。
console.log('next');
// next
// now让同步函数同步执行，异步函数异步执行，并且让它们具有统一的 API
- async()
const f = () => console.log('now');
(async () => f())(); // 立即执行的匿名函数,f是同步的，就会得到同步的结果；如果f是异步的，就可以用then指定下一步
console.log('next');
// now
// next
自己写一个f是异步的
const f= function () {
var pro = new Promise(function (resolve, reject) {
setTimeout(() => reject(new Error('我是异步哒~')), 5000)
});
return pro;
};
(async () => f())().then(function () {
console.log('我是异步哒~');
}).catch(function (error) {
alert(error);
});
console.log('next');
console.log('我是同步哒~');很好理解，5s后会弹出alert
- new Promise()
const f = () => console.log('now');
(
() => new Promise(
resolve => resolve(f())
)
)();
console.log('next');
// now
// next有一个提案，Promise.try方法替代上面的写法。
const f = () => console.log('now');
Promise.try(f);
console.log('next');
// now
// next由于Promise.try为所有操作提供了统一的处理机制，所以如果想用then方法管理流程，最好都用Promise.try包装一下。这样有许多好处，其中一点就是可以更好地管理异常。
function getUsername(userId) {
return database.users.get({id: userId})
.then(function(user) {
return user.name;
});
}
Promise.try(database.users.get({id: userId}))
.then(...)
.catch(...)此时catch能捕获所有异步和同步的错误。
454
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
