Tôi có cần quay lại sau khi giải quyết / từ chối sớm không?

Giả sử tôi có đoạn mã sau.

function divide(numerator, denominator) {
 return new Promise((resolve, reject) => {

  if(denominator === 0){
   reject("Cannot divide by 0");
   return; //superfluous?
  }

  resolve(numerator / denominator);

 });
}

Nếu mục đích của tôi là sử dụng rejectđể thoát sớm, tôi có nên tập thói quen returning ngay sau đó không?

Các returnmục đích là để chấm dứt việc thực hiện các chức năng sau khi bị từ chối, và ngăn chặn việc thực hiện các mã sau nó.

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {

    if (denominator === 0) {
      reject("Cannot divide by 0");
      return; // The function execution ends here 
    }

    resolve(numerator / denominator);
  });
}

Trong trường hợp này, nó ngăn chặn việc resolve(numerator / denominator);thực thi, không thực sự cần thiết. Tuy nhiên, vẫn nên chấm dứt việc thực hiện để ngăn chặn một cái bẫy có thể xảy ra trong tương lai. Ngoài ra, đó là một cách thực hành tốt để ngăn chặn việc chạy mã không cần thiết.

Lý lịch

Một lời hứa có thể ở một trong 3 trạng thái:

1. đang chờ xử lý - trạng thái ban đầu. Từ chờ xử lý, chúng tôi có thể chuyển sang một trong những tiểu bang khác
2. hoàn thành - hoạt động thành công
3. bị từ chối - hoạt động thất bại

Khi một lời hứa được thực hiện hoặc từ chối, nó sẽ ở trong trạng thái này vô thời hạn (giải quyết). Vì vậy, từ chối một lời hứa đã thực hiện hoặc thực hiện một lời hứa bị từ chối, sẽ không có hiệu lực.

Đoạn ví dụ này cho thấy rằng mặc dù lời hứa đã được thực hiện sau khi bị từ chối, nó vẫn bị từ chối.

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      reject("Cannot divide by 0");
    }

    resolve(numerator / denominator);
  });
}

divide(5,0)
  .then((result) => console.log('result: ', result))
  .catch((error) => console.log('error: ', error));

Vậy tại sao chúng ta cần quay trở lại?

Mặc dù chúng ta không thể thay đổi trạng thái lời hứa đã được giải quyết, việc từ chối hoặc giải quyết sẽ không dừng việc thực thi phần còn lại của chức năng. Hàm này có thể chứa mã sẽ tạo ra kết quả khó hiểu. Ví dụ:

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      reject("Cannot divide by 0");
    }
    
    console.log('operation succeeded');

    resolve(numerator / denominator);
  });
}

divide(5, 0)
  .then((result) => console.log('result: ', result))
  .catch((error) => console.log('error: ', error));

Ngay cả khi hàm không chứa mã như vậy ngay bây giờ, điều này sẽ tạo ra một cái bẫy trong tương lai. Một bộ tái cấu trúc trong tương lai có thể bỏ qua thực tế là mã vẫn được thực thi sau khi lời hứa bị từ chối và sẽ khó gỡ lỗi.

Dừng thực thi sau khi giải quyết / từ chối:

Đây là công cụ lưu lượng kiểm soát JS tiêu chuẩn.

• Quay trở lại sau resolve/ reject:

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      reject("Cannot divide by 0");
      return;
    }

    console.log('operation succeeded');

    resolve(numerator / denominator);
  });
}

divide(5, 0)
  .then((result) => console.log('result: ', result))
  .catch((error) => console.log('error: ', error));

• Trả về với resolve/ reject- vì giá trị trả về của cuộc gọi lại bị bỏ qua, chúng tôi có thể lưu một dòng bằng cách trả về câu lệnh từ chối / giải quyết:

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      return reject("Cannot divide by 0");
    }

    console.log('operation succeeded');

    resolve(numerator / denominator);
  });
}

divide(5, 0)
  .then((result) => console.log('result: ', result))
  .catch((error) => console.log('error: ', error));

• Sử dụng khối if / other:

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      reject("Cannot divide by 0");
    } else {
      console.log('operation succeeded');
      resolve(numerator / denominator);
    }
  });
}

divide(5, 0)
  .then((result) => console.log('result: ', result))
  .catch((error) => console.log('error: ', error));

Tôi thích sử dụng một trong các returntùy chọn vì mã là phẳng hơn.

Một thành ngữ phổ biến, có thể hoặc không phải là tách trà của bạn, là kết hợp returnvới reject, đồng thời từ chối lời hứa và thoát khỏi chức năng, để phần còn lại của chức năng bao gồm cả chức năng resolvekhông được thực thi. Nếu bạn thích phong cách này, nó có thể làm cho mã của bạn nhỏ gọn hơn một chút.

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) return reject("Cannot divide by 0");
                           ^^^^^^^^^^^^^^
    resolve(numerator / denominator);
  });
}

Điều này hoạt động tốt bởi vì hàm tạo Promise không làm gì với bất kỳ giá trị trả về nào, và trong mọi trường hợp resolvevà rejectkhông trả về gì cả.

Thành ngữ tương tự có thể được sử dụng với kiểu gọi lại được hiển thị trong câu trả lời khác:

function divide(nom, denom, cb){
  if(denom === 0) return cb(Error("Cannot divide by zero"));
                  ^^^^^^^^^
  cb(null, nom / denom);
} 

Một lần nữa, điều này hoạt động tốt bởi vì người gọi dividekhông mong đợi nó trả lại bất cứ điều gì và không làm bất cứ điều gì với giá trị trả lại.

Về mặt kỹ thuật không cần thiết ở đây ¹ - vì một Lời hứa có thể được giải quyết hoặc từ chối, độc quyền và chỉ một lần. Kết quả Promise đầu tiên sẽ thắng và mọi kết quả tiếp theo đều bị bỏ qua. Điều này khác với các cuộc gọi lại kiểu Node.

Điều đó được nói rằng đó là một thực hành sạch sẽ tốt để đảm bảo rằng chính xác một cái được gọi, khi thực tế, và thực sự trong trường hợp này vì không có quá trình xử lý không đồng bộ / trả chậm. Quyết định "trở về sớm" không khác gì kết thúc bất kỳ chức năng nào khi công việc của nó hoàn tất - so với việc tiếp tục xử lý không liên quan hoặc không cần thiết.

Trở lại vào thời điểm thích hợp (hoặc sử dụng các điều kiện khác để tránh thực hiện trường hợp "khác") làm giảm khả năng vô tình chạy mã trong trạng thái không hợp lệ hoặc thực hiện các tác dụng phụ không mong muốn; và do đó, nó làm cho mã ít bị "phá vỡ bất ngờ".

¹ Câu trả lời về mặt kỹ thuật này cũng xoay quanh thực tế là trong trường hợp này , mã sau khi "trả lại", nếu nó bị bỏ qua, sẽ không dẫn đến tác dụng phụ. JavaScript sẽ vui vẻ chia cho số 0 và trả về + Infinity / -Infinity hoặc NaN.

Nếu bạn không "quay lại" sau khi giải quyết / từ chối, những điều tồi tệ (như chuyển hướng trang) có thể xảy ra sau khi bạn muốn nó dừng lại. Nguồn: Tôi chạy vào đây.

Câu trả lời của Ori đã giải thích rằng nó không cần thiết returnnhưng đó là một thực hành tốt. Lưu ý rằng hàm tạo lời hứa được ném an toàn, vì vậy nó sẽ bỏ qua các ngoại lệ được ném sau đó trong đường dẫn, về cơ bản bạn có các tác dụng phụ mà bạn không thể dễ dàng quan sát được.

Lưu ý rằng returning sớm cũng rất phổ biến trong các cuộc gọi lại:

function divide(nom, denom, cb){
     if(denom === 0){
         cb(Error("Cannot divide by zero");
         return; // unlike with promises, missing the return here is a mistake
     }
     cb(null, nom / denom); // this will divide by zero. Since it's a callback.
} 

Vì vậy, trong khi đó là thông lệ tốt trong các lời hứa, nó được yêu cầu với các cuộc gọi lại. Một số lưu ý về mã của bạn:

• Trường hợp sử dụng của bạn là giả thuyết, không thực sự sử dụng lời hứa với các hành động đồng bộ.
• Hàm tạo hứa hẹn bỏ qua các giá trị trả về. Một số thư viện sẽ cảnh báo nếu bạn trả về giá trị không xác định để cảnh báo bạn trước sai lầm khi quay lại đó. Hầu hết không thông minh.
• Trình xây dựng lời hứa được ném an toàn, nó sẽ chuyển đổi các ngoại lệ thành các từ chối nhưng như những người khác đã chỉ ra - một lời hứa sẽ giải quyết một lần.

Trong nhiều trường hợp, có thể xác thực các tham số một cách riêng biệt và ngay lập tức trả lại lời hứa bị từ chối với Promise.reject (lý do) .

function divide2(numerator, denominator) {
  if (denominator === 0) {
    return Promise.reject("Cannot divide by 0");
  }
  
  return new Promise((resolve, reject) => {
    resolve(numerator / denominator);
  });
}


divide2(4, 0).then((result) => console.log(result), (error) => console.log(error));