Promise基本用法 链接

Pormise.then()

解决回调地狱等问题，通过返回then第一个参数是成功，第二个参数是失败

  1. ajax = (method, url, options)=>{
  2.   const {success, fail} = options //
  3.   const request = new XMLHttpRequest()
  4.   request.open(method, url)
  5.   request.onreadystatechange = ()=>{
  6.     if(request.readyState === 4){
  7.       // success fail
  8.       if(request.status < 400){
  9.         success.call(null, request.response)
  10.       }else if(request.status >= 400){
  11.         fail.call(null, request, request.status)
  12.       }
  13.     }
  14.   }
  15.   request.send()
  16. }
  17. ajax('get', '/xxx', {
  18.   success(response){}, fail: (request, status)=>{}
  19. }) 
  21. //改写为
  23. ajax = (method, url, options)=>{
  24.   return new Promise((resolve, reject)=>{
  25.     const {success, fail} = options
  26.     const request = new XMLHttpRequest()
  27.     request.open(method, url)
  28.     request.onreadystatechange = ()=>{
  29.       if(request.readyState === 4){
  30.       // resolve reject
  31.         if(request.status < 400){
  32.         resolve.call(null, request.response)
  33.           }else if(request.status >= 400){
  34.         reject.call(null, request)
  35.           }
  36.         }
  37.       }
  38.     request.send()
  39.   })
  40. }
  41. ajax('get', '/xxx')
  42. .then((response)=>{}, (request, status)=>{})

then方法的基础调用写法，可以写一个回调方法，来执行成功后的回调。then方法返回一个的是一个新的Promise实例，因此我们可以采用链式写法，即then方法后面再调用一个then方法。

  1. new Promise((resolve, reject) => {   resolve('Hello Promise'); })
  2.   .then(res => res)
  3.   .then(res => {console.log(res); // Hello Promise
  4.  });

Promise.catch()

  1. new Promise((resolve, reject) => {
  2.   reject('失败');
  3. }).catch(error => {
  4.   console.log(error); // 失败
  5. });

catch() 方法返回一个Promise，并且处理拒绝的情况。它的行为与调用Promise.prototype.then(undefined, onRejected) 相同。(事实上，calling obj.catch(onRejected) 内部 calls obj.then(undefined, onRejected)).

Promise.race()

**Promise.race(iterable)**方法返回一个 promise，一旦迭代器中的某个 promise 解决或拒绝，返回的 promise 就会解决或拒绝。

  1. const promise1 = new Promise((resolve, reject) => {
  2.   setTimeout(resolve, 500, 'one');
  3. });
  5. const promise2 = new Promise((resolve, reject) => {
  6.   setTimeout(resolve, 100, 'two');
  7. });
  9. Promise.race([promise1, promise2]).then((value) => {
  10.   console.log(value);
  11.   // Both resolve, but promise2 is faster
  12. });
  13. // expected output: "two"

race 函数返回一个 Promise，它将与第一个传递的 promise 相同的完成方式被完成。 它可以是完成resolves，也可以是失败rejects，这要取决于第一个完成的方式是两个中的哪个。

Promise.all()

  1. const promise1 = Promise.resolve(3);
  2. const promise2 = 42;
  3. const promise3 = new Promise((resolve, reject) => {
  4.   setTimeout(resolve, 100, 'foo');
  5. });
  7. Promise.all([promise1, promise2, promise3]).then((values) => {
  8.   console.log(values);
  9. });
  10. // expected output: Array [3, 42, "foo"]

Promise.all() 方法接收一个 promise 的 iterable 类型（注：Array，Map，Set 都属于 ES6 的 iterable 类型）的输入，并且只返回一个Promise实例， 那个输入的所有 promise 的 resolve 回调的结果是一个数组。这个Promise的 resolve 回调执行是在所有输入的 promise 的 resolve 回调都结束，或者输入的 iterable 里没有 promise 了的时候。它的 reject 回调执行是，只要任何一个输入的 promise 的 reject 回调执行或者输入不合法的 promise 就会立即抛出错误，并且 reject 的是第一个抛出的错误信息。
Promise.all等待所有都完成（或第一个失败）。

Promise.finally()

  1. let isLoading = true;
  3. fetch(myRequest).then(function(response) {
  4.     var contentType = response.headers.get("content-type");
  5.     if(contentType && contentType.includes("application/json")) {
  6.       return response.json();
  7.     }
  8.     throw new TypeError("Oops, we haven't got JSON!");
  9.   })
  10.   .then(function(json) { /* process your JSON further */ })
  11.   .catch(function(error) { console.log(error); })
  12.   .finally(function() { isLoading = false; });

finally() 方法返回一个 Promise。在 promise 结束时，无论结果是 fulfilled 或者是 rejected，都会执行指定的回调函数。这为在 Promise 是否成功完成后都需要执行的代码提供了一种方式。
这避免了同样的语句需要在 then() 和 catch() 中各写一次的情况。

回调

f2调用f1函数
f1是回调

  1. function f1(){}
  2. function f2(fn){
  3.   fn()
  4. }
  5. f2(f1)

另外一个函数接收被调用
一个函数在setTimeout / AJAX / addEventListener等里面，那么返回的就是异步函数