สัญญาจาวาสคริปต์ - ปฏิเสธกับการโยน

ฉันได้อ่านบทความหลายเรื่องในหัวข้อนี้ แต่ก็ยังไม่ชัดเจนสำหรับฉันหากมีข้อแตกต่างระหว่างPromise.rejectกับการส่งข้อผิดพลาด ตัวอย่างเช่น,

ใช้ Promise.reject

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

โดยใช้การโยน

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

การตั้งค่าของฉันคือการใช้throwเพียงเพราะมันสั้นกว่า แต่ก็สงสัยว่ามีข้อได้เปรียบของอีกคนหนึ่ง

ไม่มีประโยชน์จากการใช้ vs เทียบกับอีกอัน แต่มีบางกรณีที่throwไม่สามารถใช้งานได้ อย่างไรก็ตามกรณีเหล่านี้สามารถแก้ไขได้

throwเมื่อใดก็ตามที่คุณอยู่ในการเรียกกลับสัญญาคุณสามารถใช้ แต่ถ้าคุณอยู่ในการเรียกกลับไม่ตรงกันอื่น ๆ rejectที่คุณต้องใช้

ตัวอย่างเช่นสิ่งนี้จะไม่ทริกเกอร์การจับ:

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
});

แต่คุณจะเหลือสัญญาที่ไม่ได้รับการแก้ไขและข้อยกเว้นที่ไม่ได้ตรวจสอบ rejectนั่นคือกรณีที่คุณต้องการจะใช้งานแทน อย่างไรก็ตามคุณสามารถแก้ไขได้สองวิธี

1. โดยใช้ฟังก์ชั่นการปฏิเสธสัญญาเดิมภายในระยะเวลา:

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

2. โดยการแจ้งการหมดเวลา:

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!'
});

ข้อเท็จจริงที่สำคัญอีกข้อหนึ่งคือreject() ไม่ได้ยกเลิกโฟลว์การควบคุมเหมือนreturnคำสั่ง ในทางตรงกันข้ามthrowจะยุติการควบคุมการไหล

ตัวอย่าง:

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

VS

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"));

ใช่ความแตกต่างที่ใหญ่ที่สุดคือการปฏิเสธคือฟังก์ชันการโทรกลับที่ดำเนินการหลังจากที่สัญญาถูกปฏิเสธในขณะที่การโยนไม่สามารถใช้แบบอะซิงโครนัสได้ หากคุณเลือกที่จะใช้ปฏิเสธรหัสของคุณจะยังคงทำงานตามปกติในแบบอะซิงโครนัสในขณะที่การโยนจะจัดลำดับความสำคัญของฟังก์ชั่นตัวแก้ไขให้เสร็จสมบูรณ์ (ฟังก์ชันนี้จะทำงานทันที)

ตัวอย่างที่ฉันเคยเห็นที่ช่วยอธิบายปัญหาให้ฉันก็คือคุณสามารถตั้งค่าฟังก์ชันไทม์เอาต์ด้วยการปฏิเสธตัวอย่างเช่น

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

ข้างต้นอาจเป็นไปไม่ได้ที่จะเขียนด้วยการโยน

ในตัวอย่างเล็ก ๆ ของคุณความแตกต่างในการแยกไม่ออก แต่เมื่อจัดการกับแนวคิดอะซิงโครนัสที่ซับซ้อนกว่าความแตกต่างระหว่างทั้งสองอาจรุนแรงมาก

TLDR: ฟังก์ชั่นนั้นใช้ยากเมื่อบางครั้งส่งคืนสัญญาและบางครั้งก็เกิดข้อยกเว้น เมื่อเขียนฟังก์ชัน async ต้องการส่งสัญญาณความล้มเหลวโดยส่งคืนสัญญาที่ถูกปฏิเสธ

ตัวอย่างเฉพาะของคุณทำให้เสียความแตกต่างที่สำคัญระหว่างพวกเขา:

เนื่องจากคุณจัดการข้อผิดพลาดภายในกลุ่มสัญญาสัญญาข้อยกเว้นที่ส่งออกไปจะถูกแปลงโดยอัตโนมัติเป็นสัญญาที่ถูกปฏิเสธนี่อาจอธิบายได้ว่าทำไมพวกเขาถึงแลกเปลี่ยนกันไม่ได้

พิจารณาสถานการณ์ด้านล่าง:

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')
    }
  }

นี่จะเป็นรูปแบบการต่อต้านเพราะคุณจะต้องรองรับทั้งกรณี async และ sync อาจมีลักษณะเช่น:

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
} 

ไม่ดีและนี่คือสิ่งที่Promise.reject(ที่มีอยู่ในขอบเขตทั่วโลก) throwมาช่วยและมีประสิทธิภาพแตกต่างจาก Refactor ตอนนี้กลายเป็น:

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}`
    }
  })
}

ตอนนี้ให้คุณใช้เพียงอันเดียวcatch()สำหรับความล้มเหลวของเครือข่ายและการตรวจสอบข้อผิดพลาดแบบซิงโครนัสสำหรับการขาดโทเค็น:

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

ตัวอย่างที่จะลอง เพียงแค่เปลี่ยนเป็นรุ่นโยนเป็นเท็จเพื่อใช้ปฏิเสธแทนที่จะโยน

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)
})