Promise async_返回一个失败的promise-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_47198950/article/details/126930696

Promise是什么
抽象表达：Promise是一门新的技术
Promise是JS中进行异步编程的新解决方案
备注：旧方案是单纯使用回调函数
从语法上来时，Promise是一个构造函数
从功能上来说，Promise用来封装一个异步操作并可以获取其成功、失败的结果值
为什么要用 Promise
指定回调函数的方式更加灵活

旧的: 必须在启动异步任务前指定
promise: 启动异步任务 => 返回promie对象 => 给promise对象绑定回调函数(甚至可以在异步任务结束后指定/多个)
支持链式调用, 可以解决回调地狱问题
什么是回调地狱?
回调函数嵌套调用, 外部回调函数异步执行的结果是嵌套的回调执行的条件
回调地狱的缺点?
不便于阅读
不便于异常处理
解决方案?
promise 链式调用

Promise.resolve 方法: (value) => {}
(1) value: 成功的数据或 promise 对象
说明: 返回一个成功/失败的 promise 对象
5. Promise.reject 方法: (reason) => {}
(1) reason: 失败的原因
说明: 返回一个失败的 promise 对象
6. Promise.all 方法: (promises) => {}
(1) promises: 包含 n 个 promise 的数组
说明: 返回一个新的 promise, 只有所有的 promise 都成功才成功, 只要有一个失败了就直接失败
7. Promise.race 方法: (promises) => {}
(1) promises: 包含 n 个 promise 的数组
说明: 返回一个新的 promise, 第一个完成的 promise 的结果状态就是最终的结果状态

promise 如何串连多个操作任务?
(1) promise 的 then()返回一个新的 promise, 可以开成 then()的链式调用
(2) 通过 then 的链式调用串连多个同步/异步任务


let b1 = new Promise((resolve, reject) => {
  resolve('成功')
})
 
let b2 = new Promise((resolve, reject) => {
  resolve('success')
})
 
let b3 = Promse.reject('失败')
 
Promise.all([b1, b2]).then((result) => {
  console.log(result)               //打印结果：['成功', 'success']
}).catch((error) => {
  console.log(error)
})
 
Promise.all([b1, b2,b3]).then((result) => {
  console.log(result)
}).catch((error) => {
  console.log(error)      // 打印结果： '失败'

串联多个任务

    let p = new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve('OK');
            }, 1000);
        });

        p.then(value => {
            return new Promise((resolve, reject) => {
                resolve("success");
            });
        }).then(value => {
            console.log(value);
        })

** async 函数**

函数的返回值为 promise 对象
promise 对象的结果由 async 函数执行的返回值决定

     async function main(){
            //1. 如果返回值是一个非Promise类型的数据
            // return 521;
            //2. 如果返回的是一个Promise对象
            // return new Promise((resolve, reject) => {
            //     // resolve('OK');
            //     reject('Error');
            // });
            //3. 抛出异常
            throw "111";
     }
     let res=main();
     console.log(res);

在这里插入图片描述

await

1. await 右侧的表达式一般为 promise 对象, 但也可以是其它的值
2. 如果表达式是 promise 对象, await 返回的是 promise 成功的值
3. 如果表达式是其它值, 直接将此值作为 await 的返回值
4. 1. await 必须写在 async 函数中, 但 async 函数中可以没有 await
2. 如果 await 的 promise 失败了, 就会抛出异常, 需要通过 try...catch 捕获处理

     async function main(){
            let p = new Promise((resolve, reject) => {
                // resolve('OK');
                reject('Error');
            })
            //1. 右侧为promise的情况
            // let res = await p;
            //2. 右侧为其他类型的数据
            // let res2 = await 20;
            //3. 如果promise是失败的状态
            try{
                let res3 = await p;
            }catch(e){
                console.log(e);
            }
        }

        main();

async与await的结合

 * resource  1.html  2.html 3.html 文件内容
 */

const fs = require('fs');
const util = require('util');
const mineReadFile = util.promisify(fs.readFile);

//回调函数的方式
// fs.readFile('./resource/1.html', (err, data1) => {
//     if(err) throw err;
//     fs.readFile('./resource/2.html', (err, data2) => {
//         if(err) throw err;
//         fs.readFile('./resource/3.html', (err, data3) => {
//             if(err) throw err;
//             console.log(data1 + data2 + data3);
//         });
//     });
// });

//async 与 await
async function main(){
    try{
        //读取第一个文件的内容
        let data1 = await mineReadFile('./resource/1x.html');
        let data2 = await mineReadFile('./resource/2.html');
        let data3 = await mineReadFile('./resource/3.html');
        console.log(data1 + data2 + data3);
    }catch(e){
        console.log(e.code);
    }
}

main();
在这里插入代码片

async函数返回值是promise对象
async function(){
  return 1
}

//function fun(){
  // return new Promise((resolve)=>{
    //  resolve(1);
   //})
//}

fun().then((data)=>{
    console.log(data);
})

let p1=new Promise((resolve)=>{
     resolve(1);
})
let p2=new Promise((resolve)=>{
     resolve(2);
})

async function fun(){
   let a=await p1;
   let b=await p2;
   console.log(a);
   console.log(b);
}

fun();

async function fun1(){
    let data=await fun2();
    console.log(data);   //then中执行的代码
}
async function fun2(){
    console.log(200);  //同步
    return 100
}
fun1();  //200 100