Должен ли я использовать обещания или регулярные условия? Я смущен, когда использовать то, что [дубликат]

Реализация поддержки omnibox с предложениями по поиску

Ответ, данный @ element119, отлично работает, но вот слегка измененный код для поддержки предложений поиска, а также поддержки Mozilla.

Следуйте ниже, чтобы реализовать поддержку omni box для вашего сайта.

  1. Сохраните следующий код в качестве search.xml
<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/" xmlns:moz="http://www.mozilla.org/2006/browser/search/">
  <script/>
  <ShortName>Site Name</ShortName>
  <Description>Site Description (eg: Search sitename)</Description>
  <InputEncoding>UTF-8</InputEncoding>
  <Image width="16" height="16" type="image/x-icon">Favicon url</Image>
  <Url type="application/x-suggestions+json" method="GET" template="http://suggestqueries.google.com/complete/search?output=firefox&amp;q={searchTerms}" />
  <Url type="text/html" method="GET" template="http://yoursite.com/?s={searchTerms}" />
  <SearchForm>http://yoursite.com/</SearchForm>
</OpenSearchDescription>
  1. Загрузить search.xml к корню вашего сайта.
  2. Добавьте следующий метатег к тегу <head> вашего сайта
<link rel="search" href="http://www.yoursite.com/search.xml" type="application/opensearchdescription+xml" title="You site name"/>

Обязательно замените URL-адреса домена своим доменом .

8
задан Sean Lynch 11 July 2017 в 19:06
поделиться

3 ответа

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

Обещания отлично подходят для:

Мониторинг синхронных операций. Необходимо уведомлять только один раз (обычно это завершение или ошибка). Координация или управление несколькими асинхронными операциями, такими как последовательность или ветвление асинхронных операций или одновременное управление несколькими операциями в полете. Распространение ошибок из вложенных или глубоко вложенных асинхронных Операции Получение кода для использования async / await (или использования его сейчас с транспилером) Операции, которые соответствуют модели Promise, где есть только три состояния: pending, fulfilled и rejected и где состояние переходит из pending => fulfilled или из pending => rejected могут не меняться (один односторонний переход). Динамическое связывание или цепочка асинхронных операций (например, выполнение этих двух операций async, проверка результата, а затем принятие решения о том, какие другие операции асинхронного действия выполняются на основе промежуточного результата). Управление комбинацией асинхронных и синхронных операций. Автоматическое обнаружение и распространение любых исключений, которые происходят в асинхронных завершающих обратных вызовах (в простых обратных вызовах эти исключения иногда скрытно скрыты).

Обещания отлично подходят для:

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

И я также добавлю EventEmitter в микс.

EventEmitters отлично для:

Уведомления, которые могут возникать более одного раза (и, следовательно, необходимо вызвать обратный вызов более одного раза). Обезьяны являются одноразовыми устройствами и не могут использоваться для повторных уведомлений. Интерфейс с моделью событий, особенно когда события могут происходить более одного раза (например, потоки) Координация или управление несколькими асинхронными операциями, такими как последовательность или ветвящиеся асинхронные операции или одновременное управление несколькими операциями в полете

EventEmitters отлично подходят для:

Если ваши обратные вызовы соответствуют соглашению о вызове узла с обратным вызовом, переданным в качестве последнего аргумента и называемым как callback(err, result), то вы несколько автоматически обертываете родительскую функцию обещанием с помощью util.promisify() в node.js или используете библиотеку обещаний Bluebird , с Promise.promisify().

С помощью Bluebird вы можете даже обещать весь модуль (который использует асинхронные обратные вызовы в узле вызова node.js) сразу, например:

const Promise = require('bluebird'); const fs = Promise.promisifyAll(require('fs')); fs.writeFileAsync("file.txt", data).then(() => { // done here }).catch(err => { // error here });

В node.js версии 8 +

Теперь есть util.promisify(), который преобразует асинхронную функцию, которая использует асинхронный вызов node.js

Пример из Библиотека обещаний Bluebird

const util = require('util'); const fs = require('fs'); const stat = util.promisify(fs.stat); // usage of promisified function stat('.').then((stats) => { // Do something with `stats` }).catch((error) => { // Handle the error. });
17
ответ дан Drazen Bjelovuk 15 August 2018 в 13:15
поделиться

Я не помню, откуда я получил этот материал, но мог бы лучше понять обещания.

Обещания не являются обратными вызовами. Обещание представляет собой будущий результат асинхронной операции. Конечно, записывая их так, как вы, вы получаете небольшую выгоду. Но если вы пишете их так, как они предназначены для использования, вы можете написать асинхронный код таким образом, который напоминает синхронный код, и его гораздо проще выполнить: ПРЕИМУЩЕСТВА 1. Читаемость по обратным вызовам 2. Легко ловить ошибки. 3. Одновременные обратные вызовы

ПРЕИМУЩЕСТВА Обещания обеспечивают более сжатый и понятный способ представления последовательных асинхронных операций в javascript. Они представляют собой отличный синтаксис для достижения того же эффекта, что и обратные вызовы. Преимуществом является повышенная читаемость. Что-то вроде этого

aAsync()   .then(bAsync)   .then(cAsync)   .done(finish);

гораздо читаемо, чем эквивалент передачи каждой из этих отдельных функций в качестве обратных вызовов, таких как

Async(function(){     return bAsync(function(){         return cAsync(function(){             finish()         })     }) }); //-------------------------------------------- api().then(function(result){      return api2(); }).then(function(result2){     return api3(); }).then(function(result3){      // do work });

2. Легко ловить ошибки. Конечно, не намного меньше кода, но гораздо более удобочитаемым. Но это еще не конец. Давайте обнаружим истинные преимущества: что, если вы хотите проверить какую-либо ошибку на любом из шагов? Было бы чертовски сделать это с помощью обратных вызовов, но с обещаниями - кусок торта:

api().then(function(result){    return api2(); }).then(function(result2){     return api3(); }).then(function(result3){      // do work }).catch(function(error) {       //handle any error that may occur before this point }); /* Pretty much the same as a try { ... } catch block. Even better: */ api().then(function(result){     return api2(); }).then(function(result2){     return api3(); }).then(function(result3){      // do work }).catch(function(error) {      //handle any error that may occur before this point }).then(function() {      //do something whether there was an error or not      //like hiding an spinner if you were performing an AJAX request. });

2. Легко ловить ошибки. Что делать, если эти 3 вызова api, api2, api3 могут выполняться одновременно (например, если они были вызовами AJAX), но вам нужно было дождаться трех? Без обещаний вам нужно создать какой-то счетчик. С обещаниями, использующими нотацию ES6, это еще один кусок торта и довольно аккуратный:

Promise.all([api(), api2(), api3()]).then(function(result) {     //do work. result is an array contains the values of the three fulfilled promises. }).catch(function(error) {     //handle the error. At least one of the promises rejected. });

Надеюсь, вы увидите обещания в новом свете.

1
ответ дан Krishnadas PC 15 August 2018 в 13:15
поделиться

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

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

Обещания более распространены, так как они требуют меньше кода, более читабельны поскольку они написаны как синхронные функции, имеют один канал ошибок, могут обрабатывать заброшенные ошибки и с обратным вызовом hell , добавленным в последней версии Node.js, могут конвертировать Error-First Callbacks в обещания. Существует также async/await, который теперь также входит в Node.js, и они также взаимодействуют с Promises.

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

3
ответ дан peteb 15 August 2018 в 13:15
поделиться
  • 1
    Похоже, вы говорите, что процесс использования обратных вызовов будет заменен обещаниями. Это правда? Это то, чем я занимался с моим вопросом. Я не вижу причин использовать обратные вызовы вместо обещаний, но я решил, что это может быть наивный взгляд. Поэтому я хотел получить более широкое представление (если есть) о том, когда использовать обратные вызовы и для чего они хороши. – Sean Lynch 11 July 2017 в 19:03
  • 2
    Они не заменяются , появляются лучшие альтернативы, которые улучшают выполнение обратных вызовов, управляя асинхронной функциональностью. Что касается того, когда использовать обратные вызовы, как я сказал в своем ответе, это действительно зависит от вашего уровня комфорта с обещаниями или async/await. Люди склонны предпочитать Обещания по причинам, о которых я говорил выше и более. Я лично рекомендую использовать Promises, если ничего, кроме тех, где сообщество движется, если оно еще не было. – peteb 11 July 2017 в 19:06
Другие вопросы по тегам:

Похожие вопросы: