关键词

记录 Promise 的方法

Promise 是异步编程的一种解决方案,比传统的回调函数或事件更合理和更灵活。

Promise 方法

Promise的原型方法:then/catch/finally,这三种方法很常用,then用于处理Promise转为fulfilled状态时的代码,catch用于处理Promise转为rejected状态时的代码(当然then的第二个参数也可处理rejected状态),而finally用于不管Promise状态怎样转换都会最终执行的代码。

Promise的静态方法: Promise.all、Promise.allSettled、Promise.any、Promise.race、Promise.resolve、Promise.reject。

Promise 静态方法

Promise.resolve和Promise.reject用于一开始就创建 fulfilledrejected状态的Promise,其他的静态方法传参是Promise实例数组,差异在于处理实例数组的方式和结果。

Promise.all

并行执行多个Promise对象,并在所有Promise对象都成功时返回一个新的Promise对象,其resolve值为一个包含所有Promise结果的数组,如果其中一个Promise对象失败,则返回一个reject的Promise对象,其值为第一个失败的Promise的reject值

;(async () => {
  const promise1 = Promise.resolve('Hello')
  const promise2 = 42
  // const promise2 = Promise.reject('Error')
  const promise3 = new Promise((resolve, reject) => {
    setTimeout(resolve, 1000, 'Goodbye')
  })
  // const promise4 = Promise.reject('Error2')

  try {
    const result = await Promise.all([promise1, promise2, promise3])
    // 成功输出:[ 'Hello', 42, 'Goodbye' ]
    console.log(result)
  } catch (e) {
    // 失败输出:Error
    console.log(e)
  }
})()

Promise.allSettled

并行执行多个Promise对象,返回一个新的Promise对象(状态一定是fulfilled),其resolve值为一个包含所有Promise结果的数组,其中每个元素都是对象,包含Promise对象的状态和结果

;(async () => {
  const promise1 = Promise.resolve('Hello')
  const promise2 = 42
  // const promise2 = Promise.reject('Error')
  const promise3 = new Promise((resolve, reject) => {
    setTimeout(resolve, 1000, 'Goodbye')
  })
  // const promise4 = Promise.reject('Error2')

  try {
    const result = await Promise.allSettled([promise1, promise2, promise3])
    // 成功输出:
    // [
    //   { status: 'fulfilled', value: 'Hello' },
    //   { status: 'fulfilled', value: 42 },
    //   { status: 'fulfilled', value: 'Goodbye' }
    // ]
    console.log(result)
    // 失败输出:
    // [
    //   { status: 'fulfilled', value: 'Hello' },
    //   { status: 'rejected', reason: 'Error' },
    //   { status: 'fulfilled', value: 'Goodbye' }
    // ]
  } catch(e) {
    // 不会执行
      console.log('error:', e)
  }

  Promise.allSettled([promise1, promise2, promise3]).then((result) => {
    // 成功输出:
    // [
    //   { status: 'fulfilled', value: 'Hello' },
    //   { status: 'fulfilled', value: 42 },
    //   { status: 'fulfilled', value: 'Goodbye' }
    // ]
    console.log(result)
    // 失败输出:
    // [
    //   { status: 'fulfilled', value: 'Hello' },
    //   { status: 'rejected', reason: 'Error' },
    //   { status: 'fulfilled', value: 'Goodbye' }
    // ]
  })
})()

Promise.any

并行执行多个Promise对象,并返回一个新的Promise对象,其resolve值为第一个成功的Promise对象的resolve值,如果所有Promise对象都失败,则返回一个reject的Promise对象,其值为一个AggregateError对象,其中包含所有Promise对象的reject值。

const promise1 = Promise.reject("error1")
const promise2 = Promise.reject("error2")
const promise3 = Promise.resolve("success")
// const promise3 = Promise.reject("error3")

Promise.any([promise1, promise2, promise3]).then((value) => {
  // 成功输出:success
  console.log(value)
}).catch((error) => {
  // 失败输出:
  // [AggregateError: All promises were rejected] {
  //   [errors]: [ 'error1', 'error2', 'error3' ]
  // }
  console.log(error)
})

Promise.race

并行执行多个Promise对象,并返回一个新的Promise对象,其resolve值为第一个完成的Promise对象的resolve值,如果所有Promise对象都失败,则返回一个reject的Promise对象,其值为第一个失败的Promise的reject值。

const promise1 = Promise.reject("error1")
const promise2 = Promise.reject("error2")
const promise3 = Promise.resolve("success")
// const promise3 = Promise.reject("error3")

Promise.race([promise1, promise2, promise3]).then((value) => {
  // 成功输出:error1
  console.log(value)
}).catch((error) => {
  // 失败输出:error1
  console.log(error)
})

使用Promise实现站点预检

这是前几天实现的站点预检:判断所有网站链接是否有效,并返回测试的结果。思路:通过get请求测试,考虑请求之间没有关联、错误处理方面最终选择Promise.allSettled,代码如下:

// 实现 对多个网站链接预检,判定网站链接是否有效

import { get } from 'https'
import { get as getHttp } from 'http'
import { URL } from 'url'

import { ATagSites } from '@/type'

export const detectSitesValid = (allSites: ATagSites[]) => {
  // 遍历 allSites 数组,获取所有网站的链接
  const sites: { name: string; url: string }[] = []
  allSites.forEach((aTagSites) => {
    aTagSites.sites.forEach((site) => {
      sites.push({
        name: site.name,
        url: site.link
      })
    })
  })

  // 存储所有网站的请求
  const fetchRequests: Promise<string>[] = []
  // 存储请求结果
  const fetchResults: string[] = []

  // 遍历所有网站,发起请求
  sites.forEach((site) => {
    const { name, url } = site
    const { protocol } = new URL(url)
    const request = protocol === 'https:' ? get : getHttp
    fetchRequests.push(
      new Promise((resolve, reject) => {
        request(
          {
            hostname: new URL(url).hostname,
            path: new URL(url).pathname,
            method: 'GET',
            timeout: 30000
          },
          (res) => {
            const { statusCode, statusMessage } = res
            fetchResults.push(`${name}, ${url}, ${statusCode || 200}, ${statusMessage || 'OK'}`)
            resolve('ok')
          }
        ).on('error', (err) => {
          const { message } = err
          fetchResults.push(`${name}, ${url}, ${0}, ${message}`)
          resolve('error')
        })
      })
    )
  })

  return Promise.allSettled(fetchRequests)
}

参考

原文链接:https://www.cnblogs.com/chenmijiang/p/17314754.html

本文链接:http://task.lmcjl.com/news/9749.html

展开阅读全文