Janji JavaScript - tolak vs. lempar

Saya telah membaca beberapa artikel tentang hal ini, tetapi masih belum jelas bagi saya jika ada perbedaan antara Promise.rejectvs melempar kesalahan. Sebagai contoh,

Menggunakan Promise.reject

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

Menggunakan lemparan

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

Preferensi saya adalah menggunakan throwhanya karena lebih pendek, tetapi bertanya-tanya apakah ada kelebihan satu di atas yang lain.

Tidak ada keuntungan menggunakan satu vs yang lain, tetapi, ada kasus khusus di mana throwtidak akan berfungsi. Namun, kasus-kasus itu dapat diperbaiki.

Setiap kali Anda berada dalam janji panggilan balik, Anda dapat menggunakan throw. Namun, jika Anda menggunakan panggilan balik asinkron lainnya, Anda harus menggunakannya reject.

Misalnya, ini tidak akan memicu tangkapan:

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

Alih-alih, Anda pergi dengan janji yang tidak terselesaikan dan pengecualian yang tidak tertangkap. Itu adalah kasus di mana Anda ingin menggunakannya reject. Namun, Anda bisa memperbaikinya dengan dua cara.

1. dengan menggunakan fungsi tolak Janji asli di dalam batas waktu:

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

2. dengan menjanjikan batas waktu:

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

Fakta penting lainnya adalah reject() JANGAN menghentikan aliran kontrol seperti returnpernyataan. Sebaliknyathrow menghentikan aliran kontrol.

Contoh:

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

Ya, perbedaan terbesar adalah bahwa menolak adalah fungsi panggilan balik yang dilakukan setelah janji ditolak, sedangkan melempar tidak dapat digunakan secara tidak sinkron. Jika Anda memilih untuk menggunakan tolak, kode Anda akan terus berjalan secara normal dalam mode asinkron saat melempar akan memprioritaskan menyelesaikan fungsi penyelesai (fungsi ini akan segera berjalan).

Contoh yang pernah saya lihat yang membantu mengklarifikasi masalah bagi saya adalah Anda dapat mengatur fungsi Timeout dengan tolak, misalnya:

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

Di atas tidak mungkin menulis dengan lemparan.

Dalam contoh kecil Anda perbedaan dalam dibedakan tetapi ketika berhadapan dengan konsep asinkron yang lebih rumit perbedaan antara keduanya bisa drastis.

TLDR: Suatu fungsi sulit untuk digunakan ketika kadang-kadang mengembalikan janji dan kadang-kadang melempar pengecualian. Saat menulis fungsi async, lebih suka memberi sinyal kegagalan dengan mengembalikan janji yang ditolak

Contoh khusus Anda mengaburkan beberapa perbedaan penting di antara mereka:

Karena Anda salah menangani di dalam rantai janji, pengecualian yang dilemparkan dapat dikonversi secara otomatis menjadi janji yang ditolak. Ini mungkin menjelaskan mengapa mereka tampaknya dapat dipertukarkan - tidak.

Pertimbangkan situasi di bawah ini:

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

Ini akan menjadi anti-pola karena Anda perlu mendukung kasus kesalahan async dan sinkronisasi. Itu mungkin terlihat seperti:

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
} 

Tidak bagus dan di sinilah tempat Promise.reject(tersedia dalam lingkup global) untuk menyelamatkan dan secara efektif membedakan dirinya throw. Refactor sekarang menjadi:

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

Ini sekarang memungkinkan Anda menggunakan hanya satu catch()untuk kegagalan jaringan dan pemeriksaan kesalahan sinkron untuk kekurangan token:

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

Contoh untuk dicoba. Cukup ubah isVersionThrow to false untuk menggunakan tolak alih-alih membuang.

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