Düğüm 7 eşzamansız / bekle özelliğini kazıyorum ve böyle bir kodla karşılaşmaya devam ediyorum

function getQuote() {
  let quote = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
  return quote;
}

async function main() {
  try {
    var quote = await getQuote();
    console.log(quote);
  } catch (error) {
    console.error(error);
  }
}

main();

Bu, async / await ile çözme / reddetme veya geri dönme / atma olasılığı gibi görünüyor, ancak v8, try / catch blokları içindeki kodu optimize etmiyor mu ?!

Alternatifler var mı?

Alternatifler

Buna bir alternatif:

async function main() {
  try {
    var quote = await getQuote();
    console.log(quote);
  } catch (error) {
    console.error(error);
  }
}

açıkça vaatleri kullanarak böyle bir şey olurdu:

function main() {
  getQuote().then((quote) => {
    console.log(quote);
  }).catch((error) => {
    console.error(error);
  });
}

veya bunun gibi, devam eden geçiş stilini kullanarak:

function main() {
  getQuote((error, quote) => {
    if (error) {
      console.error(error);
    } else {
      console.log(quote);
    }
  });
}

Orijinal örnek

Orijinal kodunuzun yaptığı, yürütmeyi askıya almak ve tarafından verilen sözün yerine getirilmesini beklemektir getQuote(). Daha sonra yürütmeye devam eder ve döndürülen değeri üzerine yazar var quoteve ardından söz çözülmüşse bunu yazdırır veya bir istisna atar ve söz reddedilmişse hatayı yazdıran catch bloğunu çalıştırır.

İkinci örnekte olduğu gibi doğrudan Promise API'yi kullanarak aynı şeyi yapabilirsiniz.

Verim

Şimdi, performans için. Hadi test edelim!

Bu kodu az önce yazdım - bir dönüş değeri olarak f1()verir 1, bir istisna olarak f2()atar 1:

function f1() {
  return 1;
}

function f2() {
  throw 1;
}

Şimdi aynı kodu milyon kez arayalım, ilk olarak f1():

var sum = 0;
for (var i = 0; i < 1e6; i++) {
  try {
    sum += f1();
  } catch (e) {
    sum += e;
  }
}
console.log(sum);

Sonra 's değişikliği izin f1()için f2():

var sum = 0;
for (var i = 0; i < 1e6; i++) {
  try {
    sum += f2();
  } catch (e) {
    sum += e;
  }
}
console.log(sum);

Aldığım sonuç bu f1:

$ time node throw-test.js 
1000000

real    0m0.073s
user    0m0.070s
sys     0m0.004s

Bunun için aldım f2:

$ time node throw-test.js 
1000000

real    0m0.632s
user    0m0.629s
sys     0m0.004s

Tek iş parçacıklı bir işlemde saniyede 2 milyon atış gibi bir şey yapabileceğiniz anlaşılıyor. Bundan fazlasını yapıyorsanız, endişelenmeniz gerekebilir.

özet

Node'da böyle şeyler için endişelenmem. Böyle şeyler çok kullanılırsa, sonunda V8 veya SpiderMonkey veya Chakra ekipleri tarafından optimize edilecek ve herkes takip edecek - bu prensip olarak optimize edilmemiş gibi değil, sadece sorun değil.

Optimize edilmemiş olsa bile, CPU'nuzu Node'da maksimize ediyorsanız, muhtemelen sayınızı C ile yazmanız gerektiğini savunabilirim - diğer şeylerin yanı sıra yerel eklentiler bunun içindir. Ya da belki node.native gibi şeyler iş için Node.js'den daha uygun olabilir.

Bu kadar çok istisnanın atılması gereken bir kullanım durumunun ne olacağını merak ediyorum. Genellikle bir değer döndürmek yerine bir istisna atmak bir istisnadır.

Golang'da Hata İşlemeye Benzer Alternatif

Async / await, başlık altında sözler kullandığından, aşağıdaki gibi küçük bir yardımcı program işlevi yazabilirsiniz:

export function catchEm(promise) {
  return promise.then(data => [null, data])
    .catch(err => [err]);
}

Ardından, bazı hataları yakalamanız gerektiğinde bunu içe aktarın ve onunla bir söz veren zaman uyumsuz işlevinizi sarın.

import catchEm from 'utility';

async performAsyncWork() {
  const [err, data] = await catchEm(asyncFunction(arg1, arg2));
  if (err) {
    // handle errors
  } else {
    // use data
  }
}

Try-catch bloğuna bir alternatif, await-to-js lib'dir. Ben sık sık kullanırım. Örneğin:

import to from 'await-to-js';

async function main(callback) {
    const [err,quote] = await to(getQuote());
    
    if(err || !quote) return callback(new Error('No Quote found'));

    callback(null,quote);

}

Bu sözdizimi, try-catch ile karşılaştırıldığında çok daha temizdir.

async function main() {
  var getQuoteError
  var quote = await getQuote().catch(err => { getQuoteError = err }

  if (getQuoteError) return console.error(err)

  console.log(quote)
}

Alternatif olarak, olası bir değişkeni en üstte bir hata tutmak için bildirmek yerine yapabilirsiniz

if (quote instanceof Error) {
  // ...
}

TypeError veya Reference hatası gibi bir şey atılırsa bu işe yaramaz. Bununla birlikte, bunun normal bir hata olduğundan emin olabilirsiniz.

async function main() {
  var quote = await getQuote().catch(err => {
    console.error(err)      

    return new Error('Error getting quote')
  })

  if (quote instanceOf Error) return quote // get out of here or do whatever

  console.log(quote)
}

Bunun için tercihim, her şeyi büyük bir deneme bloğunda sarmalamak, birden fazla sözün yaratıldığı yerde, hatayı özellikle onu oluşturan söze göre ele almayı zahmetli hale getirebilir. Alternatif olarak, aynı derecede hantal bulduğum çoklu deneme blokları

Daha temiz bir alternatif şudur:

Her zaman uyumsuz işlevin teknik olarak bir vaat olması nedeniyle

Await ile çağırırken işlevlere yakalama ekleyebilirsiniz

async function a(){
    let error;

    // log the error on the parent
    await b().catch((err)=>console.log('b.failed'))

    // change an error variable
    await c().catch((err)=>{error=true; console.log(err)})

    // return whatever you want
    return error ? d() : null;
}
a().catch(()=>console.log('main program failed'))

Tüm vaat edilen hatalar ele alındığı ve kod hatalarınız olmadığı için, try catch'e gerek yok, bunu ebeveynde ihmal edebilirsiniz !!

Mongodb ile çalıştığınızı varsayalım, eğer bir hata varsa onu çağıran işlevde sarmalayıcılar yapmaktan veya try yakalamalarını kullanmaktan daha çok ilgilenmeyi tercih edebilirsiniz.

Bu şekilde yapmak istiyorum :)

const sthError = () => Promise.reject('sth error');

const test = opts => {
  return (async () => {

    // do sth
    await sthError();
    return 'ok';

  })().catch(err => {
    console.error(err); // error will be catched there 
  });
};

test().then(ret => {
  console.log(ret);
});

Hata işlemeye benzer co

const test = opts => {
  return co(function*() {

    // do sth
    yield sthError();
    return 'ok';

  }).catch(err => {
    console.error(err);
  });
};

catchTecrübelerime göre bu şekilde çalışmak tehlikelidir. Yığının tamamında atılan herhangi bir hata, yalnızca bu vaatten kaynaklanan bir hata değil (muhtemelen istediğiniz şey bu değildir) yakalanacaktır.

Bir sözün ikinci argümanı zaten bir reddedilme / başarısızlık geri aramadır. Bunun yerine onu kullanmak daha iyi ve daha güvenli.

İşte bunu halletmek için yazdığım bir typcript typafe tek satırlık:

function wait<R, E>(promise: Promise<R>): [R | null, E | null] {
  return (promise.then((data: R) => [data, null], (err: E) => [null, err]) as any) as [R, E];
}

// Usage
const [currUser, currUserError] = await wait<GetCurrentUser_user, GetCurrentUser_errors>(
  apiClient.getCurrentUser()
);