Tại sao tôi không thể ném Error cuộc gọi lại bên trong và để quá trình xử lý lỗi như thể nó ở bất kỳ phạm vi nào khác?

Nếu tôi không làm console.log(err)gì thì không được in ra và tôi không biết gì về những gì đã xảy ra. Quá trình chỉ kết thúc ...

Thí dụ:

function do1() {
    return new Promise(function(resolve, reject) {
        throw new Error('do1');
        setTimeout(resolve, 1000)
    });
}

function do2() {
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            reject(new Error('do2'));
        }, 1000)
    });
}

do1().then(do2).catch(function(err) {
    //console.log(err.stack); // This is the only way to see the stack
    throw err; // This does nothing
});

Nếu các cuộc gọi lại được thực thi trong luồng chính, tại sao Errorbị lỗ đen nuốt chửng?

Như những người khác đã giải thích, "lỗ đen" là do ném vào bên trong .catch chuỗi tiếp tục với một lời hứa bị từ chối và bạn không còn bị bắt, dẫn đến một chuỗi bị phá hủy, nuốt lỗi (xấu!)

Thêm một lần bắt nữa để xem những gì đang xảy ra:

do1().then(do2).catch(function(err) {
    //console.log(err.stack); // This is the only way to see the stack
    throw err; // Where does this go?
}).catch(function(err) {
    console.log(err.stack); // It goes here!
});

Một cú bắt ở giữa một chuỗi là hữu ích khi bạn muốn chuỗi tiến hành mặc dù bước không thành công, nhưng ném lại rất hữu ích cho tiếp tục thất bại sau khi thực hiện những việc như đăng nhập thông tin hoặc các bước dọn dẹp, thậm chí có thể thay đổi lỗi nào được ném.

Lừa

Để làm cho lỗi hiển thị là một lỗi trong bảng điều khiển web, như bạn dự định ban đầu, tôi sử dụng mẹo này:

.catch(function(err) { setTimeout(function() { throw err; }); });

Ngay cả số dòng tồn tại, do đó, liên kết trong bảng điều khiển web đưa tôi đến thẳng tệp và dòng nơi xảy ra lỗi (bản gốc).

Tại sao nó hoạt động

Bất kỳ ngoại lệ nào trong hàm được gọi là trình xử lý từ chối hoặc thực hiện lời hứa sẽ tự động được chuyển đổi thành từ chối lời hứa mà bạn phải trả lại. Mã lời hứa gọi chức năng của bạn đảm nhận việc này.

Mặt khác, một hàm được gọi bởi setTimeout, luôn chạy từ trạng thái ổn định JavaScript, tức là nó chạy trong một chu kỳ mới trong vòng lặp sự kiện JavaScript. Các trường hợp ngoại lệ không bị bắt bởi bất cứ điều gì và đưa nó vào bảng điều khiển web. Vì errchứa tất cả thông tin về lỗi, bao gồm ngăn xếp ban đầu, tệp và số dòng, nên nó vẫn được báo cáo chính xác.

Những điều quan trọng cần hiểu ở đây

1. Cả hai thenvà các catchhàm trả về các đối tượng lời hứa mới.

2. Hoặc ném hoặc từ chối rõ ràng, sẽ chuyển lời hứa hiện tại sang trạng thái bị từ chối.

3. Kể từ khi thenvà catchtrả lại các đối tượng lời hứa mới, chúng có thể bị xiềng xích.

4. Nếu bạn ném hoặc từ chối bên trong một trình xử lý lời hứa ( thenhoặc catch), nó sẽ được xử lý trong trình xử lý từ chối tiếp theo xuống đường dẫn chuỗi.

5. Như jfriend00 đã đề cập, trình xử lý thenvà catchtrình xử lý không được thực thi đồng bộ. Khi một người xử lý ném, nó sẽ kết thúc ngay lập tức. Vì vậy, ngăn xếp sẽ được mở ra và ngoại lệ sẽ bị mất. Đó là lý do tại sao ném một ngoại lệ từ chối lời hứa hiện tại.

Trong trường hợp của bạn, bạn đang từ chối bên trong do1bằng cách ném một Errorvật thể. Bây giờ, lời hứa hiện tại sẽ ở trạng thái bị từ chối và quyền kiểm soát sẽ được chuyển sang xử lý tiếp theo, đó là thentrong trường hợp của chúng tôi.

Vì thentrình xử lý không có trình xử lý từ chối, nên do2sẽ không được thực thi. Bạn có thể xác nhận điều này bằng cách sử dụng console.logbên trong nó. Vì lời hứa hiện tại không có trình xử lý từ chối, nên nó cũng sẽ bị từ chối với giá trị từ chối từ lời hứa trước đó và quyền kiểm soát sẽ được chuyển sang trình xử lý tiếp theo catch.

Như catchlà một trình xử lý từ chối, khi bạn thực hiện console.log(err.stack);bên trong nó, bạn có thể thấy dấu vết ngăn xếp lỗi. Bây giờ, bạn đang ném một Errorđối tượng từ nó để lời hứa được trả lại catchcũng sẽ ở trạng thái bị từ chối.

Vì bạn chưa đính kèm bất kỳ trình xử lý từ chối nào vào catch, nên bạn không thể quan sát từ chối.

Bạn có thể chia chuỗi và hiểu điều này tốt hơn, như thế này

var promise = do1().then(do2);

var promise1 = promise.catch(function (err) {
    console.log("Promise", promise);
    throw err;
});

promise1.catch(function (err) {
    console.log("Promise1", promise1);
});

Đầu ra bạn sẽ nhận được sẽ giống như

Promise Promise { <rejected> [Error: do1] }
Promise1 Promise { <rejected> [Error: do1] }

Trong catchtrình xử lý 1, bạn sẽ nhận được giá trị của promiseđối tượng là bị từ chối.

Tương tự, lời hứa được trả về bởi catchtrình xử lý 1, cũng bị từ chối với cùng một lỗi promisebị từ chối và chúng tôi đang quan sát nó trong catchtrình xử lý thứ hai .

Tôi đã thử setTimeout()phương pháp chi tiết ở trên ...

.catch(function(err) { setTimeout(function() { throw err; }); });

Khó chịu, tôi thấy điều này là hoàn toàn không thể kiểm chứng. Bởi vì nó gây ra lỗi không đồng bộ, bạn không thể gói nó trong một try/catchcâu lệnh, bởi vì ý catchchí đã ngừng lắng nghe bởi lỗi thời gian được đưa ra.

Tôi trở lại chỉ sử dụng một trình nghe hoạt động hoàn hảo và, bởi vì đó là cách sử dụng JavaScript, rất có thể kiểm tra được.

return new Promise((resolve, reject) => {
    reject("err");
}).catch(err => {
    this.emit("uncaughtException", err);

    /* Throw so the promise is still rejected for testing */
    throw err;
});

Theo thông số kỹ thuật (xem 3.III.d) :

d. Nếu gọi thì ném ngoại lệ e,
  a. Nếu notifyPromise hoặc từ chốiPromise đã được gọi, hãy bỏ qua nó.
  b. Nếu không, từ chối lời hứa với e là lý do.

Điều đó có nghĩa là nếu bạn ném ngoại lệ vào thenchức năng, nó sẽ bị bắt và lời hứa của bạn sẽ bị từ chối. catchđừng có ý nghĩa ở đây, nó chỉ là lối tắt để.then(null, function() {})

Tôi đoán bạn muốn đăng nhập các từ chối chưa được xử lý trong mã của bạn. Hầu hết các thư viện hứa hẹn sẽ sa thảiunhandledRejection cho nó. Đây là ý chính có liên quan với các cuộc thảo luận về nó.

Tôi biết điều này hơi muộn, nhưng tôi đã xem qua chủ đề này và không có giải pháp nào dễ thực hiện cho tôi, vì vậy tôi đã tự mình nghĩ ra:

Tôi đã thêm một chức năng trợ giúp nhỏ trả lại một lời hứa, như vậy:

function throw_promise_error (error) {
 return new Promise(function (resolve, reject){
  reject(error)
 })
}

Sau đó, nếu tôi có một vị trí cụ thể trong bất kỳ chuỗi lời hứa nào của tôi, nơi tôi muốn đưa ra một lỗi (và từ chối lời hứa), tôi chỉ cần trả về từ hàm trên với lỗi được xây dựng của mình, như vậy:

}).then(function (input) {
 if (input === null) {
  let err = {code: 400, reason: 'input provided is null'}
  return throw_promise_error(err)
 } else {
  return noterrorpromise...
 }
}).then(...).catch(function (error) {
 res.status(error.code).send(error.reason);
})

Bằng cách này, tôi kiểm soát được việc ném thêm lỗi từ bên trong chuỗi hứa hẹn. Nếu bạn cũng muốn xử lý các lỗi hứa 'bình thường', bạn sẽ mở rộng khả năng bắt để xử lý riêng các lỗi 'tự ném'.

Hy vọng điều này sẽ giúp, đó là câu trả lời stackoverflow đầu tiên của tôi!

Có hứa hẹn lỗi nuốt và bạn chỉ có thể bắt lỗi .catch, như được giải thích chi tiết hơn trong các câu trả lời khác. Nếu bạn đang ở trong Node.js và muốn tái tạo throwhành vi bình thường , in dấu vết ngăn xếp lên bàn điều khiển và quá trình thoát, bạn có thể làm

...
  throw new Error('My error message');
})
.catch(function (err) {
  console.error(err.stack);
  process.exit(0);
});