Saya sedang menggali fitur node 7 async / await dan terus menemukan kode seperti ini

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

Tampaknya ini satu-satunya kemungkinan menyelesaikan / menolak atau mengembalikan / melempar dengan async / await, namun, v8 tidak mengoptimalkan kode dalam blok coba / tangkap ?!

Apakah ada alternatif lain?

Alternatif

Alternatif untuk ini:

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

akan menjadi seperti ini, menggunakan promise secara eksplisit:

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

atau sesuatu seperti ini, menggunakan gaya passing lanjutan:

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

Contoh asli

Apa yang dilakukan kode asli Anda adalah menangguhkan eksekusi dan menunggu janji dikembalikan getQuote()untuk diselesaikan. Kemudian melanjutkan eksekusi dan menulis nilai yang dikembalikan ke var quotedan kemudian mencetaknya jika promise telah diselesaikan, atau melontarkan pengecualian dan menjalankan blok catch yang mencetak error jika promise tersebut ditolak.

Anda dapat melakukan hal yang sama menggunakan Promise API secara langsung seperti pada contoh kedua.

Performa

Sekarang, untuk pertunjukannya. Mari kita uji!

Saya baru saja menulis kode ini - f1()memberikan 1nilai pengembalian, f2()melempar 1sebagai pengecualian:

function f1() {
  return 1;
}

function f2() {
  throw 1;
}

Sekarang mari kita panggil kode yang sama jutaan kali, pertama dengan f1():

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

Dan kemudian mari beralih f1()ke f2():

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

Inilah hasil yang saya dapat f1:

$ time node throw-test.js 
1000000

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

Inilah yang saya dapatkan untuk f2:

$ time node throw-test.js 
1000000

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

Tampaknya Anda dapat melakukan sesuatu seperti 2 juta lemparan per detik dalam satu proses utas tunggal. Jika Anda melakukan lebih dari itu, Anda mungkin perlu mengkhawatirkannya.

Ringkasan

Saya tidak akan mengkhawatirkan hal-hal seperti itu di Node. Jika hal-hal seperti itu sering digunakan maka itu akan dioptimalkan pada akhirnya oleh tim V8 atau SpiderMonkey atau Chakra dan semua orang akan mengikutinya - ini tidak seperti itu tidak dioptimalkan sebagai prinsip, itu hanya bukan masalah.

Bahkan jika itu tidak dioptimalkan maka saya masih berpendapat bahwa jika Anda memaksimalkan CPU Anda di Node maka Anda mungkin harus menulis nomor Anda berderak di C - itulah tujuan dari add-on asli, antara lain. Atau mungkin hal-hal seperti node.native akan lebih cocok untuk pekerjaan itu daripada Node.js.

Saya bertanya-tanya apa yang akan menjadi kasus penggunaan yang perlu membuang begitu banyak pengecualian. Biasanya melempar pengecualian daripada mengembalikan nilai adalah pengecualian.

Alternatif Serupa Dengan Penanganan Kesalahan Di Golang

Karena async / await menggunakan promise, Anda dapat menulis sedikit fungsi utilitas seperti ini:

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

Kemudian impor setiap kali Anda perlu menemukan beberapa kesalahan, dan bungkus fungsi async Anda yang mengembalikan sebuah janji dengannya.

import catchEm from 'utility';

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

Alternatif untuk blok try-catch adalah await-to-js lib. Saya sering menggunakannya. Sebagai contoh:

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

}

Sintaks ini jauh lebih bersih jika dibandingkan dengan try-catch.

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

  if (getQuoteError) return console.error(err)

  console.log(quote)
}

Alternatifnya, alih-alih mendeklarasikan kemungkinan var untuk menahan kesalahan di atas, Anda dapat melakukannya

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

Meskipun itu tidak akan berhasil jika sesuatu seperti TypeError atau Reference error dilemparkan. Anda dapat memastikan itu adalah kesalahan biasa dengan

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

Preferensi saya untuk ini adalah membungkus semuanya dalam blok coba-tangkap besar di mana ada beberapa janji yang dibuat dapat membuatnya rumit untuk menangani kesalahan secara khusus pada janji yang membuatnya. Dengan alternatif menjadi beberapa blok coba-tangkap yang menurut saya sama-sama tidak praktis

Alternatif yang lebih bersih adalah sebagai berikut:

Karena fakta bahwa setiap fungsi asinkron secara teknis adalah sebuah janji

Anda dapat menambahkan tangkapan ke fungsi saat memanggilnya dengan await

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

Tidak perlu try catch, karena semua error promise ditangani, dan Anda tidak memiliki error kode, Anda dapat mengabaikannya di induk !!

Katakanlah Anda bekerja dengan mongodb, jika ada kesalahan Anda mungkin lebih suka menanganinya dalam fungsi yang memanggilnya daripada membuat pembungkus, atau menggunakan coba tangkap.

Saya ingin melakukan dengan cara ini :)

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

Ini mirip dengan menangani kesalahan dengan co

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

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

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

catchMenurut pengalaman saya, cara ini berbahaya. Setiap kesalahan yang terjadi di seluruh tumpukan akan ditangkap, bukan hanya kesalahan dari janji ini (yang mungkin bukan yang Anda inginkan).

Argumen kedua untuk suatu janji sudah merupakan panggilan balik penolakan / kegagalan. Lebih baik dan lebih aman untuk menggunakannya.

Berikut ini skrip ketikan satu baris yang saya tulis untuk menangani ini:

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