В этой лекции и упражнении, которое следует за этим,
мы поговорим конкретно о Callback Hell.
Проблема, которая возникает, когда вы пишете
обратные вызовы в узле и особенно вложенные обратные вызовы и узел.
Мы также рассмотрим обещания как один из способов решения проблемы обратного вызова Ада.
Чтобы дать вам представление о том, что приведет к типичной проблеме Callback Hell,
давайте вернемся к файлу index.js из предыдущего упражнения.
Когда я говорил об этом в предыдущем упражнении,
вы заметили, что для каждой из операций, которые мы выполняем,
последующая операция включается внутри функции обратного вызова здесь
и так далее, пока вы не сформируете пирамиду, подобную структуре, не пойдете снова.
Таким образом, вы видите эту пирамиду, как структуру, возникающую в вашем коде.
Теперь представьте, что вам нужно выполнить несколько вложенных операций, подобных этому,
ваш код станет довольно скоро
, очень сложным и не так легко расшифровать.
Теперь это то, что в мире node.js,
они называют «Адом обратного вызова».
Существует несколько способов смягчения возникающей проблемы.
Теперь вы можете полностью избежать этого из-за того
, что у вас есть определенные операции, которые необходимо
выполнить до начала следующей операции,
но мы можем изменить порядок кода таким образом, чтобы смягчить эту проблему.
Обещания являются одним из таких способов решения этой проблемы.
Таким образом, чтобы суммировать то, что мы только что обсудили,
сильно вложенный код
обратного вызова вызывает проблему обратного вызова, и это является
результатом нашей тенденции писать программы сверху вниз.
Мы все еще повесили наш последовательный способ написания кода, и
поэтому мы видим, что более удобно писать код сверху вниз
и смотреть на него, как будто он выполняется в этом порядке.
Теперь мы можем обойти проблему Callback Hell,
не используя анонимные функции для обратных вызовов, но вместо этого
объявляя эти функции с определенными именами,
а затем избегать того, как мы пишем код, как вы видели здесь.
Это один из подходов, которые люди используют, чтобы справиться с проблемой обратного ада.
Существует несколько других подходов, которые были предложены,
ссылки на несколько статей по этому вопросу приводятся в дополнительных ресурсах.
Но в этой конкретной лекции
я сосредоточусь на одном конкретном подходе, который
используется для решения проблемы Callback Hell,
то есть использовании обещаний.
Таким образом, мы можем использовать обещания, чтобы приручить проблему обратного вызова Ада в значительной степени.
Мы рассмотрим, как обещания помогают нам в этом отношении, и в
упражнении мы увидим, как, поскольку драйвер NODE-MONGO DB уже
поддерживает прокси-интерфейс, мы можем использовать его, чтобы переписать наш код,
чтобы воспользоваться поддержкой обещаний в драйвере MONGO DB.
Кратко обобщив, что такое обещание.
Обещание - это механизм, который поддерживает асинхронные вычисления.
Поэтому, если у вас есть объем работы, который необходимо сделать,
обещание действует как прокси для значения, которое
не известно на данный момент, но обещание дается вам.
Но когда значение станет доступным,
оно будет доступно в будущем.
Таким образом, обещание представляет собой заполнитель для этого значения.
Если значение получается правильно,
то ваше обещание правильно, и вы можете
выполнить часть кода, чтобы обработать тот факт, что обещание разрешено правильно,
если нет, то вы обрабатываете ошибку в этой ситуации.
Таким образом, обещание решится либо в решение, либо в отказ от обещания.
Ожидающее обещание может либо разрешить,
когда значение правильно получено, так что в этом случае
оно разрешится, либо то, что мы называем выполнением обещания.
Поэтому, когда обещание будет разрешено,
у вас будет кусок кода, который
обрабатывает тот факт, что обещание было разрешено.
Если обещание отклонено,
вы также должны обработать эту ситуацию
отклонением обещания соответственно в вашем коде.
Таким образом, по этой причине всякий раз, когда вы создаете обещание,
вы только указываете разрешение и варианты отклонения из него.
Вариант разрешения обычно обрабатывается врачом, а затем вариант для вашего обещания.
Так почему же мы используем обещания?
Обещания используются, потому что он
в значительной степени решает проблему обратного вызова, и обещания могут быть изменены.
Например, если у вас есть одно обещание, которое, в
свою очередь, вызывает вызов другому, который вернет обещание.
Обработка обещания может быть изменена на дескриптор предыдущего обещания.
Таким образом, вы можете иметь кучу,
а затем вызовы, которые будут обрабатывать возврат значения.
Теперь мы увидим использование этого в упражнении, которое следует за этой лекцией.
Чтобы потреблять обещание,
вы зарегистрируете соответствующую функцию обратного вызова,
когда потребитель обещания будет уведомлен либо
о выполнении, либо об отклонении обещания.
Таким образом, обратные вызовы регистрируются через .then () в обещание.
Вы будете использовать .catch (), чтобы поймать ошибки в обещании возврата.
Теперь методы.then () можно
объединить вместе, как вы увидите в следующем упражнении.
В качестве примера вы обычно обрабатываете обещание,
привязывая к значению обещания .then () и .catch ().