Использование async / await по-прежнему возвращает неопределенное

Question

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

const request = require('request');
const rp = require('request-promise');

const MongoClient = require('mongodb').MongoClient;
const ObjectId = require('mongodb').ObjectID;

const CONNECTION_STRING = process.env.DB;
const dbName = 'fcc';
const connectionOption = { useNewUrlParser: true };

function StockHandler() {

  this.latestWithoutLike = async function(ticker, multipleStock, callback) {
    if (!multipleStock) {
      console.log('Single stock');
      let lastPrice = await getLastPrice(ticker);

      if (typeof lastPrice === 'string') {
        getLikes(ticker, false, (data) => {

          let stockData = {
            stock: data.stock,
            price: lastPrice,
            likes: data.likes
          }

          return callback({ stockData: stockData });
        });
      }
    } else {
      console.log('Multiple stock');
      let firstStockLastPrice = await getLastPrice(ticker[0]);
      let secondStockLastPrice = await getLastPrice(ticker[1]);

      if (typeof firstStockLastPrice === 'string' && typeof secondStockLastPrice === 'string') {
        let firstStockLikes = await getLikes(ticker[0], false, (data) => { return data; });
        let secondStockLikes = await getLikes(ticker[1], false, (data) => { return data; });

        console.log(firstStockLikes); // <--- undefined
        console.log(secondStockLikes); // <--- undefined
      }

    } 
  };

  this.latestWithLike = async function(ticker, multipleStock, callback) {
    if (!multipleStock) {
      console.log('Single stock');
      let lastPrice = await getLastPrice(ticker);
      console.log(lastPrice);
      if (typeof lastPrice === 'string') {
        getLikes(ticker, true, (data) => {

          let stockData = {
            stock: data.stock,
            price: lastPrice,
            likes: data.likes + 1
          }

          return callback({ stockData: stockData });
        });
      }

    } else {
      console.log('Multiple stock');
      let firstStockLastPrice = await getLastPrice(ticker[0]);
      let secondStockLastPrice = await getLastPrice(ticker[1]);
      console.log(firstStockLastPrice);
      console.log(secondStockLastPrice);
    }
  };  

}

function getLastPrice(ticker) {
  let options = {
    uri:  `https://www.alphavantage.co/query?function=TIME_SERIES_INTRADAY&symbol=${ticker}&interval=1min&apikey=${process.env.ALPHA_KEY}`,
    method: 'GET',
    json: true
  }

  return rp(options)
    .then(function(parsedBody){
      let latestStockTradeTime = Object.keys(parsedBody[Object.keys(parsedBody)[1]])[0];
      let closingPrice = parsedBody[Object.keys(parsedBody)[1]][latestStockTradeTime]['4. close'];
      return closingPrice;
    })
    .catch(function(error){
      return error;
    })
}

function getLikes(ticker, likeStatus, callback) {
  MongoClient.connect(CONNECTION_STRING, connectionOption, (err, client) => {

    if (err) callback(err);

    const db = client.db(dbName);
    const collection = db.collection('stock');

    if (!likeStatus) {
      try {
        collection.findOne(
          { stock: ticker.toUpperCase() },
          { upsert: true },
          (err, result) => {
            if (result === null) {
              collection.insertOne(
                { stock: ticker.toUpperCase(), likes: 0 },
                { upsert: true },
                (err, result) => {
                  return callback(result.ops[0]);
                }
              ); 
            } else {
                return callback(result);
            }
          }
        );
      } catch (e) {
          return callback({ error: e });
      }  
    } 
    else {
      try {
        collection.findOneAndUpdate(
          { stock: ticker.toUpperCase() },
          { $inc : { likes: 1 } },
          { upsert: true, new: true },
          (err, data) => {
            return callback(data.value);
          }
        );
      } catch (e) {
          return callback({ error: e });
      }
    }

  });
};

module.exports = StockHandler;

Answer 1

Если вы определяете функцию с асинхронным поведением , вы можете использовать async/await или цепочку Promise. Внутри асинхронной функции вы можете использовать await или цепочку .then() для ожидания асинхронных ответов. Ваша функция возвращает Promise с разрешенным значением или ошибкой своим вызывающим.

async function getLikes() {
  const likes = await db.get('myLikes'); // this db method returns a Promise
  // ...
  return likes; // will return a Promise resolving likes from db or an error if there is one
}

async function logLikes() {
  const result = await getLikes();
  console.log(result);
}

Если вы используете асинхронную функцию и не ожидаете и не цепляете ответ, как в этом примере ...

async function getLikes() {
  const likes = db.get('myLikes'); // uh oh, this is asynchronous
  // ...
  return likes;
}

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