Lời hứa JavaScript - từ chối so với ném

Tôi đã đọc một số bài viết về chủ đề này, nhưng vẫn chưa rõ ràng nếu có sự khác biệt giữa Promise.rejectso với ném lỗi. Ví dụ,

Sử dụng Promise.reject

return asyncIsPermitted()
    .then(function(result) {
        if (result === true) {
            return true;
        }
        else {
            return Promise.reject(new PermissionDenied());
        }
    });

Sử dụng ném

return asyncIsPermitted()
    .then(function(result) {
        if (result === true) {
            return true;
        }
        else {
            throw new PermissionDenied();
        }
    });

Sở thích của tôi là sử dụng throwđơn giản vì nó ngắn hơn, nhưng tự hỏi liệu có bất kỳ lợi thế nào so với cái kia không.

Không có lợi thế của việc sử dụng cái này so với cái kia, nhưng, có một trường hợp cụ thể throwkhông hoạt động. Tuy nhiên, những trường hợp có thể được sửa chữa.

Bất cứ khi nào bạn ở trong một cuộc gọi lại lời hứa, bạn có thể sử dụng throw. Tuy nhiên, nếu bạn đang trong bất kỳ cuộc gọi lại không đồng bộ nào khác, bạn phải sử dụng reject.

Ví dụ: điều này sẽ không kích hoạt việc bắt:

new Promise(function() {
  setTimeout(function() {
    throw 'or nah';
    // return Promise.reject('or nah'); also won't work
  }, 1000);
}).catch(function(e) {
  console.log(e); // doesn't happen
});

Thay vào đó, bạn để lại một lời hứa chưa được giải quyết và một ngoại lệ chưa được giải quyết. Đó là một trường hợp mà bạn muốn sử dụng thay thế reject. Tuy nhiên, bạn có thể khắc phục điều này theo hai cách.

1. bằng cách sử dụng chức năng từ chối ban đầu của Promise trong thời gian chờ:

new Promise(function(resolve, reject) {
  setTimeout(function() {
    reject('or nah');
  }, 1000);
}).catch(function(e) {
  console.log(e); // works!
});

2. bằng cách hứa hẹn thời gian chờ:

function timeout(duration) { // Thanks joews
  return new Promise(function(resolve) {
    setTimeout(resolve, duration);
  });
}

timeout(1000).then(function() {
  throw 'worky!';
  // return Promise.reject('worky'); also works
}).catch(function(e) {
  console.log(e); // 'worky!'
});

Một thực tế quan trọng khác là reject() KHÔNG chấm dứt luồng kiểm soát như một returntuyên bố. Ngược lại throwkhông chấm dứt dòng điều khiển.

Thí dụ:

new Promise((resolve, reject) => {
  throw "err";
  console.log("NEVER REACHED");
})
.then(() => console.log("RESOLVED"))
.catch(() => console.log("REJECTED"));

đấu với

new Promise((resolve, reject) => {
  reject(); // resolve() behaves similarly
  console.log("ALWAYS REACHED"); // "REJECTED" will print AFTER this
})
.then(() => console.log("RESOLVED"))
.catch(() => console.log("REJECTED"));

Có, sự khác biệt lớn nhất là từ chối là chức năng gọi lại được thực hiện sau khi lời hứa bị từ chối, trong khi ném không thể được sử dụng không đồng bộ. Nếu bạn chọn sử dụng từ chối, mã của bạn sẽ tiếp tục chạy bình thường theo kiểu không đồng bộ trong khi throw sẽ ưu tiên hoàn thành chức năng trình phân giải (chức năng này sẽ chạy ngay lập tức).

Một ví dụ tôi đã thấy giúp làm rõ vấn đề với tôi là bạn có thể đặt chức năng Hết giờ với từ chối, ví dụ:

new Promise(_, reject) {
 setTimeout(reject, 3000);
});

Ở trên không thể viết bằng ném.

Trong ví dụ nhỏ của bạn, sự khác biệt không thể phân biệt nhưng khi xử lý khái niệm không đồng bộ phức tạp hơn, sự khác biệt giữa hai có thể rất lớn.

TLDR: Một chức năng khó sử dụng khi đôi khi trả lại lời hứa và đôi khi ném ngoại lệ. Khi viết chức năng không đồng bộ, thích báo hiệu thất bại bằng cách trả lại lời hứa bị từ chối

Ví dụ cụ thể của bạn che giấu một số khác biệt quan trọng giữa chúng:

Vì bạn đang xử lý lỗi trong chuỗi lời hứa, các ngoại lệ được ném sẽ tự động được chuyển đổi thành lời hứa bị từ chối. Điều này có thể giải thích tại sao chúng dường như có thể hoán đổi cho nhau - chúng không như vậy.

Hãy xem xét tình huống dưới đây:

checkCredentials = () => {
    let idToken = localStorage.getItem('some token');
    if ( idToken ) {
      return fetch(`https://someValidateEndpoint`, {
        headers: {
          Authorization: `Bearer ${idToken}`
        }
      })
    } else {
      throw new Error('No Token Found In Local Storage')
    }
  }

Đây sẽ là một mô hình chống vì bạn sẽ cần hỗ trợ cả các trường hợp lỗi không đồng bộ và đồng bộ hóa. Nó có thể trông giống như:

try {
  function onFulfilled() { ... do the rest of your logic }
  function onRejected() { // handle async failure - like network timeout }
  checkCredentials(x).then(onFulfilled, onRejected);
} catch (e) {
  // Error('No Token Found In Local Storage')
  // handle synchronous failure
} 

Không tốt và đây là chính xác nơi Promise.reject(có sẵn trong phạm vi toàn cầu) đến để giải cứu và phân biệt chính nó một cách hiệu quả throw. Bộ tái cấu trúc bây giờ trở thành:

checkCredentials = () => {
  let idToken = localStorage.getItem('some_token');
  if (!idToken) {
    return Promise.reject('No Token Found In Local Storage')
  }
  return fetch(`https://someValidateEndpoint`, {
    headers: {
      Authorization: `Bearer ${idToken}`
    }
  })
}

Điều này hiện cho phép bạn sử dụng chỉ một catch()lỗi cho lỗi mạng và kiểm tra lỗi đồng bộ về việc thiếu mã thông báo:

checkCredentials()
      .catch((error) => if ( error == 'No Token' ) {
      // do no token modal
      } else if ( error === 400 ) {
      // do not authorized modal. etc.
      }

Một ví dụ để thử. Chỉ cần thay đổi isVersionThrow thành false để sử dụng từ chối thay vì ném.

const isVersionThrow = true

class TestClass {
  async testFunction () {
    if (isVersionThrow) {
      console.log('Throw version')
      throw new Error('Fail!')
    } else {
      console.log('Reject version')
      return new Promise((resolve, reject) => {
        reject(new Error('Fail!'))
      })
    }
  }
}

const test = async () => {
  const test = new TestClass()
  try {
    var response = await test.testFunction()
    return response 
  } catch (error) {
    console.log('ERROR RETURNED')
    throw error 
  }  
}

test()
.then(result => {
  console.log('result: ' + result)
})
.catch(error => {
  console.log('error: ' + error)
})