Недостатки Asyn c и Await - NodeJs - PullRequest
Новая
       9

Недостатки Asyn c и Await - NodeJs

0 голосов
/ 19 января 2020

Я пытаюсь перейти от обратного вызова к асинхронному / ожиданию. Я знаю, что async / await прост в использовании, удобочитаем, меньше кода и может избежать ада обратного вызова. Но каковы недостатки, такие как производительность?

Ответы [ 2 ]

0 голосов
/ 20 января 2020

Если вы сравниваете простые асинхронные обратные вызовы с использованием обещаний с await, недостатков на самом деле не очень много. Сами по себе обещания являются просто лучшим способом кодирования асинхронных операций, чем простые обратные вызовы, и обещания с await обычно проще написать, чем даже простые обещания.

Так что, если бы мне пришлось поцарапать дно ствола чтобы попытаться перечислить некоторые недостатки, это все, что я могу придумать:

  1. async/await не будет работать в более старых средах (старые браузеры, старые версии node.js), если только Вы сначала переносите это. Вы не можете заполнить новый синтаксис языка, как это. Тебе придется провести. Простой код обратного вызова может работать в более старых версиях движка. И даже код обещания, написанный без async/await, может быть заполнен для запуска в более старых версиях.

  2. Это что-то новое, чтобы научиться правильно использовать. Я вижу много новичков, пытающихся await вещей, которые не возвращают обещание, а затем удивляются, почему это не работает так, как они хотят.

  3. Обещания создают дополнительные Объект обещания для управления движком и сборщиком мусора по сравнению с обычным асинхронным обратным вызовом. Тесты, которые показали другие, не показывают какой-либо значимой разницы в производительности. Эти объекты обещают быть маленькими, и интерпретатор JS был довольно хорошо оптимизирован для работы с множеством мелких объектов (поскольку это то, что он делает все время).

Там Есть так много преимуществ использования обещаний и async/await, что я никогда не сталкивался с ситуацией и не слышал о том, чтобы кто-нибудь сталкивался с ситуацией, когда дополнительный объект обещания, который создает движок, был значительным или актуальным. Вы получаете большую отдачу от затраченных средств со всеми преимуществами использования обещаний для управления потоком и последовательностью асинхронных операций и для распространения ошибок по желанию.

0 голосов
/ 19 января 2020

это более современный и элегантный способ обработки неизвестных временных ситуаций. Одним из больших различий или преимуществ между традиционным обратным вызовом и этим современным способом является простота обслуживания. его чистый и читаемый.

ниже я напишу пример. если вы видите необходимость постоянно вкладывать один уровень глубже и один уровень глубже для каждого действия, нежелательно. это кошмар, когда ты вкладываешь столько слоев в глубину. 

// tradiatonal callback
eatBreakfast(function(){
  eatLunch(function(){
    eatDinner()
  })
})

// functions

function eatBreakfast(callback) {
  console.log("The eatBreakfast function started executing.")
  setTimeout(function() {
    addText("You just ate breakfast.")
    if (callback) callback()
  }, 800)
}

function eatLunch(callback) {
  console.log("The eatLunch function started executing.")
  setTimeout(function() {
    addText("You just ate lunch.")
    if (callback) callback()
  }, 300)
}

function eatDinner(callback) {
  console.log("The eatDinner function started executing.")
  setTimeout(function() {
    addText("You just ate dinner.")
    if (callback) callback()
  }, 600)
}

здесь это современный способ справиться с этой ситуацией. Одно из больших преимуществ использования обещаний заключается в том, что вам не нужно продолжать вложение на один уровень глубже для каждого события. легче понять или управлять бесконечно вложенным обратным вызовом. 

// 1
eatBreakfast().then(function(){
  return eatLunch()
}).then(function(){
  eatDinner()
})

// 2 => even easier to look with arrow functions
eatBreakfast()
.then(() => eatLunch())
.then(() => eatDinner())

//3 => even more clear way by this magical await word.
async function runOurActions() {
  await eatBreakfast()
  await eatLunch()
  await eatDinner()
}

// 4 => add error handling
async function runOurActions() {
  try {
    await eatBreakfast()
    await eatLunch()
    await eatDinner()
  } catch(err) {
    console.log(err)
  }
}



// functions return promises
function eatBreakfast() {
  return new Promise(function(resolve, reject) {
    console.log("The eatBreakfast function started executing.")
    setTimeout(function() {
      addText("You just ate breakfast.")
      resolve()
    }, 800)
  })
}

function eatLunch() {
  return new Promise(function(resolve, reject) {
    console.log("The eatLunch function started executing.")
    setTimeout(function() {
      addText("You just ate lunch.")
      resolve()
    }, 300)
  })
}

function eatDinner() {
  return new Promise(function(resolve, reject) {
    console.log("The eatDinner function started executing.")
    setTimeout(function() {
      addText("You just ate dinner.")
      resolve()
    }, 600)
  })
}
...