Làm cách nào để từ chối theo cú pháp async / await?

Làm cách nào tôi có thể từ chối lời hứa được trả về bởi hàm async / await?

vd

foo(id: string): Promise<A> {
  return new Promise((resolve, reject) => {
    someAsyncPromise().then((value)=>resolve(200)).catch((err)=>reject(400))
  });
}

Dịch sang async / await

async foo(id: string): Promise<A> {
  try{
    await someAsyncPromise();
    return 200;
  } catch(error) {//here goes if someAsyncPromise() rejected}
    return 400; //this will result in a resolved promise.
  });
}

Vì vậy, làm thế nào tôi có thể từ chối lời hứa này trong trường hợp này?

Tốt nhất là để throwmột Errorgói giá trị, mà kết quả trong một lời hứa từ chối với một Errorgói giá trị:

} catch (error) {
    throw new Error(400);
}

Bạn cũng có thể chỉ throwlà giá trị, nhưng sau đó không có thông tin theo dõi ngăn xếp:

} catch (error) {
    throw 400;
}

Thay phiên, trả lại một lời hứa bị từ chối với Errorgói giá trị, nhưng nó không phải là thành ngữ:

} catch (error) {
    return Promise.reject(new Error(400));
}

(Hoặc chỉ return Promise.reject(400);, nhưng một lần nữa, sau đó không có thông tin ngữ cảnh.)

(Trong trường hợp của bạn, vì bạn đang sử dụng TypeScriptvà foogiá trị truy xuất là Promise<A>, bạn sẽ sử dụng return Promise.reject<A>(400 /*or error*/);)

Trong một tình huống async/ await, cái cuối cùng có lẽ là một chút của một trận đấu sai ngữ nghĩa, nhưng nó hoạt động.

Nếu bạn ném một cái Error, nó chơi tốt với mọi thứ tiêu tốn fookết quả của bạn bằng awaitcú pháp:

try {
    await foo();
} catch (error) {
    // Here, `error` would be an `Error` (with stack trace, etc.).
    // Whereas if you used `throw 400`, it would just be `400`.
}

Có lẽ cũng nên đề cập rằng bạn chỉ có thể xâu chuỗi một catch()chức năng sau khi cuộc gọi hoạt động không đồng bộ của bạn vì dưới mui xe vẫn có một lời hứa được trả lại.

await foo().catch(error => console.log(error));

Bằng cách này bạn có thể tránh try/catchcú pháp nếu bạn không thích nó.

Bạn có thể tạo một hàm bao bọc nhận lời hứa và trả về một mảng có dữ liệu nếu không có lỗi và lỗi nếu có lỗi.

function safePromise(promise) {
  return promise.then(data => [ data ]).catch(error => [ null, error ]);
}

Sử dụng nó như thế này trong ES7 và trong một async chức năng:

async function checkItem() {
  const [ item, error ] = await safePromise(getItem(id));
  if (error) { return null; } // handle error and return
  return item; // no error so safe to use item
}

Cách tốt hơn để viết chức năng async sẽ là bằng cách trả lại một Promise đang chờ xử lý từ đầu và sau đó xử lý cả từ chối và giải quyết trong cuộc gọi lại của lời hứa, thay vì chỉ đưa ra một lời hứa bị từ chối do lỗi. Thí dụ:

async foo(id: string): Promise<A> {
    return new Promise(function(resolve, reject) {
        // execute some code here
        if (success) { // let's say this is a boolean value from line above
            return resolve(success);
        } else {
            return reject(error); // this can be anything, preferably an Error object to catch the stacktrace from this function
        }
    });
}

Sau đó, bạn chỉ cần chuỗi phương thức trên lời hứa trả lại:

async function bar () {
    try {
        var result = await foo("someID")
        // use the result here
    } catch (error) {
        // handle error here
    }
}

bar()

Nguồn - hướng dẫn này:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise

Tôi có một đề nghị để xử lý các từ chối đúng cách trong một cách tiếp cận mới lạ, mà không có nhiều khối thử bắt.

import to from './to';

async foo(id: string): Promise<A> {
    let err, result;
    [err, result] = await to(someAsyncPromise()); // notice the to() here
    if (err) {
        return 400;
    }
    return 200;
}

Nơi nhập hàm to.ts từ:

export default function to(promise: Promise<any>): Promise<any> {
    return promise.then(data => {
        return [null, data];
    }).catch(err => [err]);
}

Tín dụng đi đến Dima Grossman trong liên kết sau .

Đây không phải là câu trả lời cho câu hỏi của @TJ Crowder. Chỉ là một bình luận phản hồi bình luận "Và thực tế, nếu ngoại lệ sẽ được chuyển thành từ chối, tôi không chắc liệu tôi có thực sự bị làm phiền nếu đó là Lỗi hay không. Lý do của tôi chỉ ném Lỗi có thể không áp dụng. "

nếu mã của bạn đang sử dụng async/ await, thì đó vẫn là một cách tốt để từ chối Errorthay vì 400:

try {
  await foo('a');
}
catch (e) {
  // you would still want `e` to be an `Error` instead of `400`
}

Tôi biết đây là một câu hỏi cũ, nhưng tôi chỉ vấp phải chủ đề và dường như có một sự nhầm lẫn ở đây giữa các lỗi và từ chối chạy afoul (ít nhất là trong nhiều trường hợp) về lời khuyên lặp đi lặp lại không sử dụng xử lý ngoại lệ để đối phó với các trường hợp dự đoán. Để minh họa: nếu phương thức async đang cố xác thực người dùng và xác thực không thành công, đó là từ chối (một trong hai trường hợp dự đoán) và không phải là lỗi (ví dụ: nếu API xác thực không khả dụng.)

Để chắc chắn rằng tôi không chỉ chẻ sợi tóc, tôi đã chạy thử nghiệm hiệu suất của ba cách tiếp cận khác nhau, sử dụng mã này:

const iterations = 100000;

function getSwitch() {
  return Math.round(Math.random()) === 1;
}

function doSomething(value) {
  return 'something done to ' + value.toString();
}

let processWithThrow = function () {
  if (getSwitch()) {
    throw new Error('foo');
  }
};

let processWithReturn = function () {
  if (getSwitch()) {
    return new Error('bar');
  } else {
    return {}
  }
};

let processWithCustomObject = function () {
  if (getSwitch()) {
    return {type: 'rejection', message: 'quux'};
  } else {
    return {type: 'usable response', value: 'fnord'};
  }
};

function testTryCatch(limit) {
  for (let i = 0; i < limit; i++) {
    try {
      processWithThrow();
    } catch (e) {
      const dummyValue = doSomething(e);
    }
  }
}

function testReturnError(limit) {
  for (let i = 0; i < limit; i++) {
    const returnValue = processWithReturn();
    if (returnValue instanceof Error) {
      const dummyValue = doSomething(returnValue);
    }
  }
}

function testCustomObject(limit) {
  for (let i = 0; i < limit; i++) {
    const returnValue = processWithCustomObject();
    if (returnValue.type === 'rejection') {
      const dummyValue = doSomething(returnValue);
    }
  }
}

let start, end;
start = new Date();
testTryCatch(iterations);
end = new Date();
const interval_1 = end - start;
start = new Date();
testReturnError(iterations);
end = new Date();
const interval_2 = end - start;
start = new Date();
testCustomObject(iterations);
end = new Date();
const interval_3 = end - start;

console.log(`with try/catch: ${interval_1}ms; with returned Error: ${interval_2}ms; with custom object: ${interval_3}ms`);

Một số nội dung trong đó được đưa vào vì sự không chắc chắn của tôi liên quan đến trình thông dịch Javascript (tôi chỉ muốn đi xuống một lỗ thỏ tại một thời điểm); chẳng hạn, tôi đã bao gồm doSomethinghàm và gán trở lại của nó dummyValueđể đảm bảo rằng các khối có điều kiện sẽ không được tối ưu hóa.

Kết quả của tôi là:

with try/catch: 507ms; with returned Error: 260ms; with custom object: 5ms

Tôi biết rằng có rất nhiều trường hợp không đáng để tìm kiếm những tối ưu hóa nhỏ, nhưng trong các hệ thống quy mô lớn hơn, những điều này có thể tạo ra sự khác biệt tích lũy lớn, và đó là một so sánh khá rõ ràng.

Trong khi tôi nghĩ rằng cách tiếp cận của câu trả lời được chấp nhận là hợp lý trong trường hợp bạn muốn xử lý các lỗi không thể đoán trước trong một hàm không đồng bộ, trong trường hợp từ chối đơn giản có nghĩa là "bạn sẽ phải đi với Kế hoạch B (hoặc C, hoặc Dạn) "Tôi nghĩ rằng sở thích của tôi sẽ là từ chối sử dụng một đối tượng phản hồi tùy chỉnh.