在线学习Node.js——Day3

今天又星期一了，每周一都是满课，呜呜呜。对了！我又发现除了PHP Ajax外我还想学的一个东东了，就是less...啊，感觉我的前端生涯道阻且长捏。

---

Promise的进一步学习

        在昨天，我已经学习了Promise的创建方法、如何从promise中获取数据、promise的两个隐藏属性、Promise的then()方法、Promise的catch()方法、Promise的finally()方法。回到一开始，我们为什么要学习Promise？因为我们要解决“回调地狱”的问题。

在Promise中的：then()、catch()、finally()

        1、这三个方法都会返回一个新的Promise，相当于 then( return new Promise() )

        2、Promise中会存储回调函数的返回值

        3、finally的返回值，不会存到新的Promise中

以then为例子：then执行后每次总会返回一个新的Promise，并将then中回调函数的返回值存储到这个Promise中，如果没有指定返回值则新Promise中不会存储任何值。

以下是Promise的链式调用

const promise = new Promise((resolve, reject)=>{
    resolve("第一步执行结果")
})

promise.then(result => {
    console.log("收到结果：", result)
    return "第二步执行结果" // 会作为新的结果存储到新Promise中
}).then(result => {
    console.log("收到结果：", result)
    return "第三步执行结果" // 会作为新的结果存储到新Promise中
})

对promise进行链式调用时，后边的方法（then 和 catch）读取的是上一步的结果，如果上一步的执行结果不是当前想要的结果，则会跳过当前的方法，当Promise出现异常时，而整个调用链中没有出现catch，则异常会被抛出。

有了Promise方法后，我们就可以解决“回调地狱”的问题了，具体范例代码如下：

function sum(a,b){
    return new Promise( (resolve,reject) => {
       setTimeout( () => {
        resolve(a+b)
       },1000)
    })
}

由于sum的返回值是一个Promise，所以我们不在需要通过回调函数来读取结果：

sum(123,456)
    .then(result => result + 7)
    .then(result => result + 8)
    .then(result => result + 9)
    .then(result => console.log(result))
//返回603

而如果代码中，乱入了一个catch()，且我们没有调用reject，则会自动忽略跳过它

sum(123,456)
    .then(result => result + 7)
    .catch(result => console.log(result))  //乱入的家伙
    .then(result => result + 8)
    .then(result => result + 9)
    .then(result => console.log(result))
//依旧返回603

但是当我们调用reject的时候：

//about catch() - 跳过了第一个then()  后边方法读的是前一个方法的结果
     const promise3 = new Promise( (resolve,reject) => {
        reject("我是最初的Promise的返回值")
    })
    promise3
        .then( r => console.log("第一个then",r))
        .catch( v => {
            console.log("异常处理",v)
            return "我是console的返回值"
                })
        .then(q => console.log("第二个then",q))

//返回值为：
//    异常处理 我是最初的Promise的返回值
//    第二个then 我是console的返回值

Promise的静态方法

静态方法（类方法，直接通过类去调用的方法）

        Promise.resolve() 创建一个立即完成的Promise

Promise.resolve(10).then(r => console.log(r))
       

        Promise.reject() 创建一个立即拒绝的Promise

Promise.reject("错误").catch(r => console.log(r))

      

         Promise.all([...]) 同时返回多个Promise的执行结果

                特点：其中有一个错误，就返回错误（不求同年同月同日生，但求同年同月同日死）

function sum(a,b){
    return new Promise( (resolve,reject) => {
       setTimeout( () => {
        resolve(a+b)
       },1000)
    })
}

// .all
    Promise.all([
        sum(1,4),
        sum(12,45),
        sum(123,456)
    ]).then( r => {
        console.log(r);
    })
//返回 [5, 57, 579]

    Promise.all([
        sum(1,4),
        sum(12,45),
        Promise.reject("我是捣蛋鬼"),
        sum(123,456)
    ]).then( r => {
        console.log(r);
    })
//同年同月同日s了,会报错

        

        Promise.allSettled([...]) 同时返回多个Promise的执行结果

                无论成功或失败都返回，返回的是对象数组 (用断点调试)（不求同年同月同日死）

// .allSettled 
Promise.allSettled([
    sum(1,4),
    sum(12,45),
    Promise.reject("haha"),
    sum(123,456)
]).then( r => {
    console.log(r);
} )
//返回 [{…}, {…}, {…}, {…}] 是对象数组 （用断点调试，可以看到返回的东东）

        

        Promise.race([...]) 返回首先执行完的Promise, 不论对错

// .race  谁跑的快返回谁,不考虑对错
Promise.race([
    Promise.reject(555),
    sum(1,4),
    sum(12,45),
    sum(123,456)
]).then( r => {
    console.log(r)
}).catch( r => {
    console.log("错误")
})

//返回 “错误”

       

        Promise.any([...]) 只会返回第一个成功的Promise，忽略错误的（如果所有的Promise都失败才会返回一个错误信息）

// .any 谁跑的快返回谁，忽略错误的
Promise.any([
    Promise.reject(666),
    sum(1,4),
    sum(12,45),
    sum(123,456)
]).then( r => {
    console.log(r)
}).catch( r => {
    console.log("错误")
})

//返回 5

---

今天又吃了一个苹果，好幸福好高兴，希望早点解封，我害想吃橘子捏！