在JavaScript的世界中,所有代码都是单线程执行的。由于这个“缺陷”,导致JavaScript的所有网络操作,浏览器事件,都必须是异步执行。原来异步执行都用回调函数实现,现在可以使用Promise来实现异步。
有时在业务中需要执行一层套一层套一层...的异步回调来获取数据,也就是地狱回调,
$.ajax({ url:"", success: function(res1){ $.ajax({ url:"", data: {key:res1}, success: function(res2){ $.ajax({ url:"", data: {key:res2}, success:function(res3){ } }) } }) } })
现在可以使用Promise来解决地狱回调的复杂嵌套问题。
var p = new Promise((res,rej)=>{ let data = 10; // 使用setTimeout模拟异步,data是异步请求回的数据,setTimeout其实有三个值,第三个值是第一个值函数的参数 setTimeout(res,1000,data+data) }); function a(data){ return new Promise((res,rej)=>{ setTimeout(res,1000,data+data) }) }; function b(data){ return new Promise((res,rej)=>{ setTimeout(res,1000,data+data) }) }; p.then(function(res){ console.log(res); // 20 return a(res) }).then(function(res){ console.log(res); //40 return b(res) }).then(function(res){ console.log(res); //80 });
描述
Promise
对象是一个代理对象(代理一个值),被代理的值在Promise对象创建时可能是未知的。它允许你为异步操作的成功和失败分别绑定相应的处理方法(handlers)。 这让异步方法可以像同步方法那样返回值,但并不是立即返回最终执行结果,而是一个能代表未来出现的结果的promise对象。
一个 Promise有以下几种状态:
pending: 初始状态,既不是成功,也不是失败状态。
fulfilled: 意味着操作成功完成。
rejected: 意味着操作失败
pending 状态的 Promise 对象可能会变为fulfilled 状态并传递一个值给相应的状态处理方法,也可能变为失败状态(rejected)并传递失败信息。当其中任一种情况出现时,Promise 对象的 then
方法绑定的处理方法(handlers )就会被调用(then方法包含两个参数:onfulfilled 和 onrejected,它们都是 Function 类型。当Promise状态为fulfilled时,调用 then 的 onfulfilled 方法,当Promise状态为rejected时,调用 then 的 onrejected 方法, 所以在异步操作的完成和绑定处理方法之间不存在竞争)。
因为
和 Promise.prototype.then
方法返回promise 对象, 所以它们可以被链式调用。Promise.prototype.catch
语法
new Promise( function(resolve, reject) {...}
方法
1、Promise.prototype.catch(onRejected)
添加一个拒绝(rejection) 回调到当前 promise, 返回一个新的promise。当这个回调函数被调用,新 promise 将以它的返回值来resolve,否则如果当前promise 进入fulfilled状态,则以当前promise的完成结果作为新promise的完成结果
2、.Promise.prototype.then(onFulfilled, onRejected)
添加解决(fulfillment)和拒绝(rejection)回调到当前 promise, 返回一个新的 promise, 将以回调的返回值来resolve.
3、Promise.prototype.finally(onFinally)
添加一个事件处理回调于当前promise对象,并且在原promise对象解析完毕后,返回一个新的promise对象。回调会在当前promise运行完毕后被调用,无论当前promise的状态是完成(fulfilled)还是失败(rejected)
备注:由于 then()
和 catch()方法都会返回 promise,它们可以被链式调用,由此才可以实现then的链式调用来实现多重回调
实例
1、一般promise
var p = new Promise(function(resolve,reject){
// 当异步代码执行成功时,我们才会调用resolve(...),当异步代码失败时调用reject(...);
// 使用setTimeout(...)来模拟异步代码
if(Math.random()>0.5){ setTimeout(resolve,1000,res) }else{ setTimeout(reject,1000,rej) } }); p.then(function(res){ console.log(res); }).catch(function(rej){ console.log(rej); });
2、当promise的then中存在两个函数,且走reject回调失败时,catch中的错误回调无效
var a = new Promise((resolve,reject)=>{ if(false){ resolve('这是大于0.5') } else { reject("这是小于等于0.5"); } }); a.then( function(res){console.log("then");console.log(res)} ).catch( function(res){console.log("catch");console.log(res)} // catch 这是小于等于0.5 ); a.then( function(res){console.log("then");console.log(res)}, function(rej){console.log("then");console.log(rej)} // then 这是小于等于0.5 ).catch( function(rej){console.log("catch");console.log(rej)} );
3、地狱回调:不同人写的处理地狱回调方式中return的数量不一样,造成困惑,仔细观察还是有不同
function multiply(input) { return new Promise(function (resolve, reject) { console.log('calculating ' + input + ' x ' + input + '...'); setTimeout(resolve, 500, input * input); }); }; function add(input) { return new Promise(function (resolve, reject) { console.log('calculating ' + input + ' + ' + input + '...'); setTimeout(resolve, 500, input + input); }); }; var p = new Promise(function (resolve, reject) { console.log('start new Promise...'); resolve(123); });
// 这是把自定义函数直接当做then中的匿名函数,所有只需要在自定义的函数中返回promise就可以实现then的链式调用 p.then(multiply) .then(add) .then(multiply) .then(add) .then(function (result) { console.log('Got value: ' + result); });
// 严格按照then中的匿名函数写法,先是自定义函数内部return出promise实例,再在匿名函数中return出promise实例,这样就可以实现then的链式调用
p.then(
function(res){
return multiply(res)
}
).then(
function(res){
return add(res)
}
).then(
function(res){
return multiply(res)
}
).then(
function(res){
return add(res)
}
).then(
function(res){
console.log('Got value'+res)
}
)
Promise.all(iterable) :iterable是一个可迭代对象,如 Array
或 String
Promise.all(iterable)
方法返回一个 Promise
实例,此实例在 iterable
参数内所有的 promise
都“完成(resolved)”或参数中不包含 promise
时回调完成(resolve);如果参数中 promise
有一个失败(rejected),此实例回调失败(reject),失败的原因是第一个失败 promise
的结果。
const p1 = Promise.resolve(3); const p2 = 42; const p3 = new Promise(function(resolve, reject) { setTimeout(resolve, 100, 'foo'); });
const p4 = new Promise(function(resolve,reject){
setTimeout(reject,1000,'fail')
}) Promise.all([p1, p2, p3]).then(function(values) { console.log(values); }); // expected output: Array [3, 42, "foo"]
Promise.all([p1,p2,p3,p4]).then(function(res){
console.log(res)
}).catch(function(rej){
console.log("rej:"+rej)
})
// expected output: String rej:fail
Promise.race(iterable) :iterable是一个可迭代对象,如 Array
或 String
顾名思义,Promse.race就是赛跑的意思,意思就是说,Promise.race([p1, p2, p3])里面哪个结果获得的快,就返回那个结果,不管结果本身是成功状态还是失败状态,如果出现同时,那么久看Promise的哪个实例的位置,实例最早,就返回那个结果,无论成功状态还是失败状态。不是race中数组的位置,是在js中promise实例位置。
let p1 = new Promise(function(resolve,reject){ setTimeout(resolve,1000,"时间1000,p1的resolve成功") }); let p2 = new Promise(function(resolve,reject){ setTimeout(resolve,500,'时间:500,p2的resolve成功') }) let p3 = new Promise(function(resolve,reject){ setTimeout(reject,1000,"时间1000,p3的reject失败") }); let p4 = new Promise(function(resolve,reject){ setTimeout(reject,500,'时间:500,p4的reject失败') }); let p5 = new Promise(function(resolve,reject){ setTimeout(resolve,1000,'时间:1100,p5的resolve成功') }); Promise.race([p1,p2]).then(function(res){ console.log(res); // 时间500,p2的resolve成功 }).catch(function(rej){ console.log(rej); }); Promise.race([p1,p3]).then(function(res){ console.log(res); // 时间1000,p1的resolve成功 }).catch(function(rej){ console.log(rej); }); Promise.race([p3,p1]).then(function(res){ console.log(res); // 时间1000,p1的resolve成功 }).catch(function(rej){ console.log(rej); }); Promise.race([p1,p5]).then(function(res){ console.log(res); // 时间1000,p1的resolve成功 }).catch(function(rej){ console.log(rej); }); Promise.race([p5,p1]).then(function(res){ console.log(res); // 时间1000,p1的resolve成功 }).catch(function(rej){ console.log(rej); }); Promise.race([p1,p4]).then(function(res){ console.log(res); }).catch(function(rej){ console.log(rej); // 时间:500,p4的reject成功 }); Promise.race([p2,p3]).then(function(res){ console.log(res); // 时间:500,p2的resolve成功 }).catch(function(rej){ console.log(rej); }); Promise.race([p2,p4]).then(function(res){ console.log(res); // 时间:500,p2的resolve成功 }).catch(function(rej){ console.log(rej); }); Promise.race([p3,p4]).then(function(res){ console.log(res); }).catch(function(rej){ console.log(rej); // 时间:500,p4的reject失败 });
Promise.reject()方法返回一个带有拒绝原因的Promise
对象
静态函数Promise.reject
返回一个被拒绝的Promise对象
。通过使用Error
的实例获取错误原因reason
对调试和选择性错误捕捉很有帮助。
function resolved(result) { console.log('Resolved'); } function rejected(result) { console.error(result); } Promise.reject(new Error('fail')).then(resolved, rejected); // expected output: Error: fail
Promise.resolve(value)
返回一个以给定值解析后的Promise
对象。如果这个值是一个 promise ,那么将返回这个 promise ;如果这个值是thenable(即带有"then"
方法),返回的promise会“跟随”这个thenable的对象,采用它的最终状态;否则返回的promise将以此值完成。此函数将类promise对象的多层嵌套展平。
// Resolve一个thenable对象 var p1 = Promise.resolve({ then: function(onFulfill, onReject) { onFulfill("fulfilled!"); } }); console.log(p1 instanceof Promise) // true, 这是一个Promise对象 p1.then(function(v) { console.log(v); // 输出"fulfilled!" }, function(e) { // 不会被调用 }); // Thenable在callback之前抛出异常 // Promise rejects var thenable = { then: function(resolve) { throw new TypeError("Throwing"); resolve("Resolving"); }}; var p2 = Promise.resolve(thenable); p2.then(function(v) { // 不会被调用 }, function(e) { console.log(e); // TypeError: Throwing }); // Thenable在callback之后抛出异常 // Promise resolves var thenable = { then: function(resolve) { resolve("Resolving"); throw new TypeError("Throwing"); }}; var p3 = Promise.resolve(thenable); p3.then(function(v) { console.log(v); // 输出"Resolving" }, function(e) { // 不会被调用 });