Как отправить несколько запросов с одной конечной точки на Express?

Я пытаюсь несколько раз запросить мою базу данных и построить объект, который хранит каждый ответ из моей базы данных в поле. Вот мой код:

router.post('/search', (req, res) => {
    var collection = db.get().collection('styles')
    var data = [];

    collection.distinct('make.name', (err, docs) => {
      data.push({'make': docs });
    });

    collection.distinct('model', (function (err, docs) {
        data.push({'model': docs });
    }))

    res.send(data);
});

Так как NodeJS/Express является асинхронным, это не работает, как хотелось бы. Как я могу восстановить эту конечную точку, чтобы сделать несколько вызовов базы данных (из одной коллекции) и вернуть объект, содержащий ее?

ОТВЕТЫ

Ответ 1

Там более одного способа сделать это:

Вложенные обратные вызовы

Без promises вы можете вложить обратные вызовы:

router.post('/search', (req, res) => {
    var collection = db.get().collection('styles')
    var data = [];

    collection.distinct('make.name', (err, docs) => {
      if (err) {
        // ALWAYS HANDLE ERRORS!
      }
      data.push({'make': docs });
        collection.distinct('model', (function (err, docs) {
          if (err) {
            // ALWAYS HANDLE ERRORS!
          }
          data.push({'model': docs });
          res.send(data);
        }))
    });
});

Это было бы самым простым способом, но обратите внимание, что это неэффективно, если эти два запроса могут выполняться параллельно.

Модуль async

Вы можете использовать модуль async:

router.post('/search', (req, res) => {
    var collection = db.get().collection('styles')
    var data = [];

    async.parallel({
      make: cb => collection.distinct('make.name', cb),
      model: cb => collection.distinct('model', cb),
    }, (err, responses) => {
      if (err) {
        // ALWAYS HANDLE ERRORS!
      }
      data.push({'make': responses.make });
      data.push({'model': responses.model });
      res.send(data);
    });
});

Смотрите: https://caolan.github.io/async/docs.html#parallel

Но это может быть не самым удобным способом.

ES2017 async/await

Самый гибкий способ сделать это, если у вас есть 30 вызовов сделать, будет:

  • Используйте функции, которые возвращают promises вместо функций, которые принимают обратные вызовы
  • Использовать async/await, если вы можете или, по крайней мере, создавать сопрограммы на основе генераторов
  • Ожидание promises (или выход promises), когда логика должна выполняться последовательно
  • Используйте Promise.all() для всего, что можно сделать параллельно

С асинхронным/ожиданием ваш код может выглядеть так:

    // in sequence:    
    var make = await collection.distinct('make.name');
    var model = await collection.distinct('model');
    // use 'make' and 'model'

Или:

    // in parallel:
    var array = await Promise.all([
      collection.distinct('make.name'),
      collection.distinct('model'),
    ]);
    // use array[0] and array[1]

Большим преимуществом async/await является обработка ошибок:

try {
  var x = await asyncFunc1();
  var array = await Promise.all([asyncFunc2(x), asyncFunc3(x)]);
  var y = asyncFunc4(array);
  console.log(await asyncFunc5(y));
} catch (err) {
  // handle any error here
}

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

Для поддержки в браузерах см.

Для поддержки в Node см.

В местах, где у вас нет встроенной поддержки async и await, вы можете использовать Babel:

или со слегка отличающимся синтаксисом, основанным на генераторе, как в co или сопрограмме Bluebird:

Смотрите эти ответы для получения дополнительной информации:

Ответ 2

Вы можете сделать это с помощью Promises

router.post('/search', (req, res) => {
    var collection = db.get().collection('styles');
    // Create promise for "make.name" query
    let firstQuery = new Promise((resolve, reject) => {
        collection.distinct('make.name', (err, docs) => {
            if (!err) {
                resolve(docs);
            } else {
                reject(err);
            }
        });
    });
    // Create promise for "model" query
    let secondQuery = new Promise((resolve, reject) => {
        collection.distinct('model', (function (err, docs) {
            if (!err) {
                resolve(docs);
            } else {
                reject(err);
            }
        }))
    })
    // Run both queries at the same time and handle both resolve results or first reject
    Promise.all([firstQuery, secondQuery])
        .then((results) => {
            res.send({ "make.name": results[0], "model": results[1] });
        })
        .catch((err) => {
            // Catch error 
            res.send({});
        });
});

Также вы можете использовать деструктурирование в таких функциях обратного вызова:

Promise.all([firstQuery, secondQuery])
    .then(([makeName, model]) => res.send({ "make.name": makeName, model }))

UPD: если у вас есть куча коллекции для запроса, вы можете создать массив имен коллекций, сопоставить их с обещаниями и обработать с помощью Promise.all, например

let collections = ["firstCollection", "secondCollection", "nCollection"];
let promises = collections.map((collectionName) => {
    return new Promise((resolve, reject) => {
        collection.distinct(collectionName, (err, docs) => {
            if (!err) {
                resolve(docs)
            } else {
                reject(err);
            }
        });
    })
});
Promise.all(promises)
    .then(results => {
        // Do what you want to do
    })
    .catch(error => {
        // or catch 
    });