Erken çözümden / reddetmeden sonra geri dönmem gerekir mi?

Aşağıdaki kodu aldığımı varsayalım.

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

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

  resolve(numerator / denominator);

 });
}

rejectAmacım erken çıkmak için kullanmaksa return, hemen sonra da ing alışkanlığına girmeli miyim ?

returnAmaç reddi sonra fonksiyonunun uygulanmasını sona erdirme ve ondan sonra kod yürütülmesini önlemek içindir.

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

Bu durumda resolve(numerator / denominator);, kesinlikle gerekli olmayan çalıştırılmasını engeller . Bununla birlikte, gelecekte olası bir tuzağı önlemek için yürütmeyi sonlandırmak hala tercih edilir. Ayrıca, kodun gereksiz yere çalıştırılmasını önlemek için iyi bir uygulamadır.

Arka fon

Bir söz 3 durumdan birinde olabilir:

1. bekleyen - başlangıç ​​durumu. Beklemeden diğer eyaletlerden birine geçebiliriz
2. yerine getirildi - başarılı operasyon
3. reddedildi - başarısız işlem

Bir söz yerine getirildiğinde veya reddedildiğinde, bu durumda süresiz olarak kalır (kararlaştırılır). Dolayısıyla, yerine getirilen bir sözü reddetmek veya reddedilen bir sözü yerine getirmek, etkili olmayacaktır.

Bu örnek pasaj, sözün reddedildikten sonra yerine getirilmesine rağmen reddedildiğini göstermektedir.

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

Öyleyse neden geri dönmemiz gerekiyor?

Yerleşik bir vaat durumunu değiştiremesek de, reddetmek veya çözmek fonksiyonun geri kalanının yürütülmesini durdurmaz. İşlev, kafa karıştırıcı sonuçlar yaratacak bir kod içerebilir. Örneğin:

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

İşlev şu anda böyle bir kod içermiyor olsa bile, bu olası bir gelecekteki tuzak oluşturur. Gelecekteki bir refactor, söz verildikten sonra kodun hala yürütüldüğünü görmezden gelebilir ve hata ayıklamak zor olacaktır.

Çözme / reddetme işleminden sonra yürütmeyi durdurma:

Bu standart JS kontrol akışı şeyleridir.

• Sonra İade 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));

• İle Dönüş resolve/ reject- callback'inde dönüş değeri göz ardı edilir, çünkü biz / gidermek ifadeyi reddetmek dönerek bir çizgi kaydedebilirsiniz:

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

• Bir if / else bloğu kullanma:

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

returnKod düz olduğundan seçeneklerden birini kullanmayı tercih ederim .

Çay bardağınız olabilir veya olmayabilir, ortak bir deyim, returnile rejectvaadi reddetmek ve işlevden çıkmak için birleştirmektir , böylece işlevi içeren işlevin geri kalanı resolveyürütülmez. Bu stili beğendiyseniz, kodunuzu biraz daha kompakt hale getirebilir.

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

Promise yapıcı herhangi bir dönüş değeri ile hiçbir şey yapmaz ve her durumda resolveve rejecthiçbir şey döndürmez , çünkü bu iyi çalışır .

Aynı deyim, başka bir cevapta gösterilen geri arama stiliyle kullanılabilir:

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

Yine, bu iyi çalışır çünkü arayan kişi dividehiçbir şey geri dönmesini beklemez ve dönüş değeri ile hiçbir şey yapmaz.

Teknik olarak burada gerekli değildir ¹ - çünkü bir Söz sadece ve sadece bir kez çözülebilir veya reddedilebilir . İlk Promise sonucu kazanır ve sonraki her sonuç göz ardı edilir. Bu, Düğüm stili geri aramalardan farklıdır .

Bununla birlikte , pratik olduğunda ve gerçekten de bu durumda daha fazla asenkron / ertelenmiş işlem olmadığı için tam olarak bir kişinin çağrılmasını sağlamak iyi bir temiz uygulamadır . "Erken dönme" kararı , işi tamamlandığında herhangi bir işlevi sonlandırmaktan farklı değildir - ilgisiz veya gereksiz işlemeye devam etmek.

Uygun zamanda geri dönmek (veya "diğer" durumu yürütmekten kaçınmak için koşullu kullanmak) yanlışlıkla kodu geçersiz bir durumda çalıştırma veya istenmeyen yan etkiler yapma olasılığını azaltır; ve böylece kodu 'beklenmedik şekilde kırılmaya' daha az eğilimli hale getirir.

¹ Bu teknik cevap ayrıca , bu durumda , "geri dön" den sonraki kodun atlanması durumunda, bir yan etkiye neden olmayacağı gerçeğine de bağlıdır . JavaScript mutlu bir şekilde sıfıra bölünecek ve + Infinity / -Infinity veya NaN döndürecektir.

Bir çözümleme / reddetme işleminden sonra "geri dönmezseniz", durmayı düşündükten sonra kötü şeyler (sayfa yönlendirmesi gibi) olabilir. Kaynak: Buna rastladım.

Ori'nin cevabı zaten gerekli olmadığını açıklıyor, returnancak iyi bir uygulama. Söz vericinin güvenli bir şekilde atıldığını unutmayın, böylece yolda daha sonra geçirilen istisnaları göz ardı eder, aslında kolayca gözlemleyemediğiniz yan etkilere sahip olursunuz.

returnErken aramanın geri aramalarda da çok yaygın olduğunu unutmayın :

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

Bu nedenle, vaatlerde iyi bir uygulama olsa da geri aramalarla gereklidir . Kodunuzla ilgili bazı notlar:

• Kullanım durumunuz varsayımsaldır, aslında senkron eylemlerle vaatler kullanmayın.
• Promise yapıcısı dönüş değerlerini yok sayar . Bazı kütüphaneler, oraya dönme hatasına karşı sizi uyarmak için tanımlanmamış bir değer döndürürseniz uyarır. Çoğu o kadar akıllı değil.
• Vaat kurucusu güvenli bir şekilde atıldı, istisnaları reddetmelere dönüştürecek, ancak diğerlerinin işaret ettiği gibi - bir söz bir kez çözülüyor.

Birçok durumda parametreleri ayrı ayrı doğrulamak ve Promise.reject (reason) ile derhal reddedilen bir söz vermek mümkündür .

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