错误处理

本节目标：理解“错误处理”的核心思路，并能把它用于实际开发或面试表达。

说明：原 OneNote 中有图片引用，但图片未包含在导出目录中；本页保留了可用的文字与代码内容。

一、Reject但没有明确return值
async function foo() {
    console.log(1);
    Promise.reject(3);
}
foo().then(console.log, console.log)
返回值：

异步函数内部reject()一个值，并没有return一个值的效果，所以上面的函数实际上还是返回了一个resolve(undefined)的Promise，所以没有被promise拒绝回调捕获；

二、函数内部了抛错
异步函数内部throw 错误有return一个值的效果，会返回一个拒绝的期约；
async function foo() {
    console.log(1);
    throw 2
}
foo().catch(console.log)
输出：1  2

三、await后promise Reject或抛错
如果await后面的异步操作reject()了，那么等同于async函数返回的 Promise 对象被reject.
async function foo() {
    await Promise.reject(2)
}
foo().then(console.log)
// UnhandledPromiseRejectionWarning: 2

如果await后面的异步操作出错，那么等同于async函数返回的 Promise 对象被reject。 async function f()


 `{`
    `await` `new`

Promise(function

(resolve,

reject)


 `{`
        `throw` `new`

Error('


出错了

');

}); } f().then(v


 `=>`

console.log(v))

.catch(e


 `=>`

console.log(e)) // Error：出错了上面代码中，async函数f执行后，await后面的 Promise 对象会抛出一个错误对象，导致catch方法的回调函数被调用，它的参数就是抛出的错误对象。

防止出错的方法，也是将其放在try...catch代码块之中。
`async` `function`

f()


 `{`
    `try` `{`
        `await` `new`

Promise(function

(resolve,

reject)


 `{`
            `throw` `new`

Error('


出错了

');

         `});`
    `}` `catch`

(e)


 `{`
    `}`
    `return` `await`

('hello

world'); }


如果有多个await命令，可以统一放在try...catch结构中。
`async` `function`

main()


 `{`
    `try` `{`
        `const` `val1` `=` `await`

firstStep();

         `const` `val2` `=` `await`

secondStep(val1);

         `const` `val3` `=` `await`

thirdStep(val1,

val2);

console.log('Final:

val3);

     `}`
    `catch`

(err)

`{`

console.error(err);

} }

 下面的例子使用try...catch结构，实现多次重复尝试。
`const` `superagent` `=`

require('superagent'); const


 `NUM_RETRIES` `=`

3; async


 `function`

test()


 `{`
    `let`

     `for`

`=`


 `i` `<`

NUM_RETRIES;

++i)


 `{`
        `try` `{`
            `await`

superagent.get('http://google.com/this-throws-an-error');

break;

         `}` `catch`

(err)


 `{` `}`
    `}`

console.log(i);


 `//`

3 } test(); 上面代码中，如果await操作成功，就会使用break语句退出循环；如果失败，会被catch语句捕捉，然后进入下一轮循环。

使用注意点 第一点，前面已经说过，await命令后面的Promise对象，运行结果可能是rejected，所以最好把await命令放在try...catch代码块中。 async function myFunction()


 `{`
    `try` `{`
        `await`

somethingThatReturnsAPromise();

     `}` `catch`

(err)

`{`

console.log(err);

} } //


 另一种写法
`async` `function`

myFunction()


 `{`
    `await`

somethingThatReturnsAPromise()

.catch(function

(err)

`{`

console.log(err);

}); } 第二点，多个await命令后面的异步操作，如果不存在继发关系，最好让它们同时触发。 let foo = await getFoo(); let bar = await getBar(); 上面代码中，getFoo和getBar是两个独立的异步操作（即互不依赖），被写成继发关系。这样比较耗时，因为只有getFoo完成以后，才会执行getBar，完全可以让它们同时触发。 // 写法一 let [foo,

bar]


 `=` `await`

Promise.all([getFoo(),

getBar()]); //


 写法二
`let` `fooPromise` `=`

getFoo(); let


 `barPromise` `=`

getBar(); let


 `foo` `=` `await`

fooPromise; let


 `bar` `=` `await`

barPromise; 上面两种写法，getFoo和getBar都是同时触发，这样就会缩短程序的执行时间。

第三点，await命令只能用在async函数之中，如果用在普通函数，就会报错。 async function dbFuc(db)


 `{`
    `let` `docs` `=` `[{},` `{},` `{}];`
    `//` 报错

docs.forEach(function

(doc)


 `{`
        `await`

db.post(doc);

}); } 上面代码会报错，因为await用在普通函数之中了。但是，如果将forEach方法的参数改成async函数，也有问题。 function dbFuc(db)


 `{` `//`这里不需要 `async`
    `let` `docs` `=` `[{},` `{},` `{}];`
    `//` 可能得到错误结果

docs.forEach(async


 `function`

(doc)


 `{`
        `await`

db.post(doc);

}); } 上面代码可能不会正常工作，原因是这时三个db.post操作将是并发执行，也就是同时执行，而不是继发执行。正确的写法是采用for循环。 async function dbFuc(db)


 `{`
    `let` `docs` `=` `[{},` `{},` `{}];`
    `for`

(let


 `doc` `of`

docs)


 `{`
        `await`

db.post(doc);

} }

 另一种方法是使用数组的reduce方法。
`async` `function`

dbFuc(db)


 `{`
    `let` `docs` `=` `[{},` `{},` `{}];`
    `await`

docs.reduce(async

(_,

doc)


 `=>` `{`
        `await`

         `await`

db.post(doc);

     `},`

undefined); } 上面例子中，reduce方法的第一个参数是async函数，导致该函数的第一个参数是前一步操作返回的 Promise 对象，所以必须使用await等待它操作结束。另外，reduce方法返回的是docs数组最后一个成员的async函数的执行结果，也是一个 Promise 对象，导致在它前面也必须加上await。

如果确实希望多个请求并发执行，可以使用Promise.all方法。当三个请求都会resolved时，下面两种写法效果相同。 async function dbFuc(db)


 `{`
    `let` `docs` `=` `[{},` `{},` `{}];`
    `let` `promises` `=`

docs.map((doc)


 `=>`

db.post(doc));

     `let` `results` `=` `await`

Promise.all(promises);

console.log(results); } //


 或者使用下面的写法
`async` `function`

dbFuc(db)


 `{`
    `let` `docs` `=` `[{},` `{},` `{}];`
    `let` `promises` `=`

docs.map((doc)


 `=>`

db.post(doc));

     `let` `results` `=` `[];`
    `for`

(let


 `promise` `of`

promises)

`{`

results.push(await

promise);

`}`

console.log(results); }

第四点，async 函数可以保留运行堆栈。
`const` `a` `=` `()` `=>` `{`

b().then(()


 `=>`

c()); };

 上面代码中，函数a内部运行了一个异步任务b()。当b()运行的时候，函数a()不会中断，而是继续执行。等到b()运行结束，可能a()早就运行结束了，b()所在的上下文环境已经消失了。如果b()或c()报错，错误堆栈将不包括a()。
现在将这个例子改成async函数。
`const` `a` `=` `async` `()` `=>` `{`
    `await`

b();

c(); }; 上面代码中，b()运行的时候，a()是暂停执行，上下文环境都保存着。一旦b()或c()报错，错误堆栈将包括a()。

错误处理 ​

错误处理