同时使用 async/await 和 .then().catch() 有什么害处吗，比如：
async apiCall(params) {
var results = await this.anotherCall()
.then(results => {
//do any results transformations
return results;
})
.catch(error => {
//handle any errors here
});
return results;
}
我经常使用async/await和.catch()来使代码更加紧凑，而不是使用async/await和try/catch。
async function asyncTask() {
throw new Error('network')
}
async function main() {
const result = await asyncTask().catch(error => console.error(error));
console.log('result:', result)
}
main();.catch() 方法中返回一个值。
async function asyncTask() {
throw new Error('network')
}
async function main() {
const result = await asyncTask().catch(_ => 'fallback value');
console.log('result:', result)
}
main();result =行之后还有更多的代码。假设出现了错误。那么result是未定义的吗？ - Jeff Padgett.catch()方法返回一个备用值。 - Lin Duawait时没有包含任何then子句，这正是问题所在！ - S.Serpooshan不想唤起死者，但想指出使用await与then链结合使用意味着：
const x = await someAsyncFn().then(() => doSomeLogging());
变量x被赋值为.then的返回值（如果doSomeLogging是无返回值，则为undefined），这对我来说并不是很直观。
.then 中等待值，那么添加 await 的意义何在？代码如何工作？变量 x 的值将是多少？ - Mohammed Shahedpromise.then()，在另一个上下文中使用await。这样，您的API模块可以执行许多后处理数据的操作，而调用者只需await最终的promise，无需了解具体细节。 - undefined异步函数可以包含一个await表达式，它可以暂停异步函数的执行，并等待传递的Promise解决，然后恢复异步函数的执行并返回解决的值。
从下面的示例中可以看出，您可以使用两种方式处理等待结果和错误。关键字 await 使 JavaScript 等待直到该 promise 解决，并返回其结果(即您从已解决的 promise 中获得的结果)。因此，并没有什么危害（我不完全理解您在这里所指的危害是什么）。
function returnpromise(val) {
return new Promise((resolve, reject) => {
if (val > 5) {
resolve("resolved"); // fulfilled
} else {
reject("rejected"); // rejected
}
});
}
//This is how you handle errors in await
async function apicall() {
try {
console.log(await returnpromise(5))
} catch (error) {
console.log(error)
}
}
async function apicall2() {
let data = await returnpromise(2).catch((error) => {
console.log(error)
})
}
apicall2();
apicall();更多参考请查看-MDN文档
我认为混合使用async/await和then不是一个好主意，特别是当你专注于异步函数的结果时，混合使用会带来一些风险，可能会悄悄地扭曲你的结果。
例子：
const res = await fetchData().then(()=>{return "something else"}).catch((err)=>{});
console.log(res); // not expected res data but something else
所以，混合使用是很危险的，顺便说一下，它会对阅读代码造成伤害。
await 和 then 会影响可读性，但我不理解你在这里的例子。 - ggorlen.then()方法，只需将resolve()返回的结果存储在变量中（例如示例中的response）。但是，如果要处理错误，您需要使用try/catch语句包裹您的代码：async function f() {
try {
let response = await fetch('http://no-such-url');
} catch(err) {
alert(err); // TypeError: failed to fetch
}
}
throw new Error("oops!");
或者
Promise.reject(new Error("Whoops!"));
.then和另一个匿名的异步函数更好，后者会使整个代码难以理解。 - scavengertry/catch。你可以使用 .then() 和 .catch() 以及 await。问题是这样做是否好。 - ggorlen.then，当涉及错误处理并且没有必要访问无法直接通过链传递的对象上的状态时，它可以更简洁一些。fetch("https://www.example.com")
.then(response => {
if (!response.ok) {
throw Error(response.statusText);
}
return response.json();
)
.then(data => console.log(data))
.catch(err => console.error(err));
对我来说，这个看起来比较干净：
(async () => {
try {
const response = await fetch("https://www.example.com");
if (!response.ok) {
throw Error(response.statusText);
}
console.log(response.json());
}
catch (err) {
console.error(err);
}
})();
await，底部的代码变得更加吸引人，尽管在实践中，你通常是在编写一个函数。await链上使用.catch来避免一种有点丑陋的try/catch。const fs = require("node:fs/promises");
const exists = async pathName =>
!!(await fs.stat(pathName).catch(() => false));
async/await/try/catch版本：const exists = async pathName => {
try {
await fs.stat(pathName);
return true;
}
catch (err) {
return false;
}
};
...或者也许不是，这取决于你是否认为catch版本太聪明了。
请注意，这里没有混合使用.then和await，只是用.catch而不是try/except。这里的一般启发式原则是"越扁平越好"（.catch比try/catch更扁平，await比.then更扁平）。
（是的，这个例子有点牵强，因为在这个特定任务中有一种相当简洁的使用.then/.catch的方法，但这种模式可能会偶尔出现在其他上下文中）
如果有任何疑问，请坚持"永不混合"的原则。
await和then（以及其他一些Promise反模式）而导致的混淆问题的一小部分示例：.then() 而不是 .catch() - 例如，在您的第一个片段中也可以使用它。 - Bergiawait/then混用都是有问题的，并且源于困惑。要知道它可以被明智地使用的少数边缘情况需要很多经验，因此我认为最好建议他们基本上永远不要混用（除非你真的知道自己在做什么）。 - ggorlen这样做没有什么坏处，但会增加代码量并使代码难以阅读， 你可以尝试这样做：
async apiCall(params) {
try{
var results = await this.anotherCall()
return results;
} catch(err){
//do something with the error
}
}
虽然我不确定你在这里想做什么，但是只在try块中返回results意味着该函数可能会在错误情况下返回undefined。
此外，重要的是要记住异步函数始终返回一个Promise，因此使用apiCall函数有两种方式：
// 1- using .then to access the returned value
apiCall().then(results => {
if(results){
//doing something with the results
}
})
// 2- awaiting the function inside another async function
async anotherFunction(){
const results = await apiCall();
if(results){
//doing something with the results
}
}
使用if(results)可以确保您处理的不是undefined。
if？这里大部分的代码都是不必要的。 - ggorlenawait和then之间的区别，以便理解将它们混合使用的合理性。
await会暂停异步语义执行链，直到完成参数异步调用。这意味着当前的异步函数不会完成其语义执行，而是允许处理消息队列中的其他运行异步调用和任务，同时进行await。
then是一种让当前函数体完全结束执行并返回的方式，因此可以在异步调用图中启动其他调用，而无需等待结果，而是附加具有闭包的回调函数，该闭包包含完成线程上下文中执行逻辑所需的所有内容。async链之前等待，并且需要在继续当前异步调用链之前完成then lambda，那么在异步函数上下文中放置await在then上语义上等同于将语句拆分为两个不需要闭包的等待。使用一次await用于异步调用，第二次用于then参数，而不是使用then使代码更易读，因为可以多行显示且减少了闭包。
因此，在这种情况下，语义上没有太多的理由将两者混合使用。
但是，如果你的函数完成了所有其他任务，并且在语义上返回之前没有等待完成的理由，那么使用await关键字和then/catch会在性能方面更好地解决异步图。
await？如果有的话，可能每个语句都使用await更好，因为这样更易读。如果有一种方法可以封闭所需的任何内容并使用then链而不使用await，那么异步函数可能会在语义上立即返回以继续其他调用，并且最好根本不使用任何await。但同时使用两者几乎没有任何意义。// MODULE-1
export async function apiCall(params) {
return apiInstance.someRequest(params)
.then(results => {
//do any results transformations
return processedResults;
})
.catch(error => {
//handle any errors here
});
}
// MODULE-2
import { apiCall } from 'MODULE-1'
async function consumeApi() {
... do something
const processedResults = await apiCall()
.... do something else
}
async apiCall(params) {
var results = await this.anotherCall()
.then(async (results) => {
//do any results transformations
await //your action
return results;
})
.catch(error => {
//handle any errors here
});
return results;
}
await将Promise链的最终值传递给result变量。 - yqlim