Как обернуть вызовы асинхронных функций в функцию синхронизации в Node.js или Javascript?

deasync превращает асинхронную функцию в синхронизацию, реализованную с помощью механизма блокировки, путем вызова цикла событий Node.js на уровне JavaScript. В результате deasync только блокирует выполнение последующего кода, не блокируя весь поток и не вызывая ожидания занятости. С помощью этого модуля вот ответ на вызов jsFiddle:

function AnticipatedSyncFunction(){
  var ret;
  setTimeout(function(){
      ret = "hello";
  },3000);
  while(ret === undefined) {
    require('deasync').runLoopOnce();
  }
  return ret;    
}


var output = AnticipatedSyncFunction();
//expected: output=hello (after waiting for 3 sec)
console.log("output="+output);
//actual: output=hello (after waiting for 3 sec)

(отказ от ответственности: я являюсь соавтором deasync. Модуль был создан после публикации этого вопроса и не нашел работоспособного предложения.)

Также существует модуль синхронизации npm. который используется для синхронизации процесса выполнения запроса.

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

Образец кода

/*require sync module*/
var Sync = require('sync');
    app.get('/',function(req,res,next){
      story.find().exec(function(err,data){
        var sync_function_data = find_user.sync(null, {name: "sanjeev"});
          res.send({story:data,user:sync_function_data});
        });
    });


    /*****sync function defined here *******/
    function find_user(req_json, callback) {
        process.nextTick(function () {

            users.find(req_json,function (err,data)
            {
                if (!err) {
                    callback(null, data);
                } else {
                    callback(null, err);
                }
            });
        });
    }

справочная ссылка: https://www.npmjs.com/package/sync

Вы должны использовать обещания:

const asyncOperation = () => {
    return new Promise((resolve, reject) => {
        setTimeout(()=>{resolve("hi")}, 3000)
    })
}

const asyncFunction = async () => {
    return await asyncOperation();
}

const topDog = () => {
    asyncFunction().then((res) => {
        console.log(res);
    });
}

Мне больше нравятся определения стрелочных функций. Но любую строку вида «() => {...}» можно также записать как «function () {...}»

Таким образом, topDog не является асинхронным, несмотря на вызов асинхронной функции.

РЕДАКТИРОВАТЬ: Я понимаю, что во многих случаях вам нужно обернуть асинхронную функцию внутри функции синхронизации внутри контроллера. Для таких ситуаций есть трюк для вечеринки:

const getDemSweetDataz = (req, res) => {
    (async () => {
        try{
            res.status(200).json(
                await asyncOperation()
            );
        }
        catch(e){
            res.status(500).json(serviceResponse); //or whatever
        }
    })() //So we defined and immediately called this async function.
}

Используя это с обратными вызовами, вы можете сделать обертку, которая не использует обещания:

const asyncOperation = () => {
    return new Promise((resolve, reject) => {
        setTimeout(()=>{resolve("hi")}, 3000)
    })
}

const asyncFunction = async (callback) => {
    let res = await asyncOperation();
    callback(res);
}

const topDog = () => {
    let callback = (res) => {
        console.log(res);
    };

    (async () => {
        await asyncFunction(callback)
    })()
}

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

Если функция Fiber действительно превращает спящий режим асинхронной функции в синхронизацию

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

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

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

Моя цель - минимизировать влияние на вызывающего абонента при изменении метода сбора данных с синхронизации на асинхронный.

И обещания, и волокна могут это сделать.

В настоящее время этот шаблон генератора может быть решением во многих ситуациях.

Вот пример последовательных подсказок консоли в nodejs с использованием функции async readline.question:

var main = (function* () {

  // just import and initialize 'readline' in nodejs
  var r = require('readline')
  var rl = r.createInterface({input: process.stdin, output: process.stdout })

  // magic here, the callback is the iterator.next
  var answerA = yield rl.question('do you want this? ', r=>main.next(r))    

  // and again, in a sync fashion
  var answerB = yield rl.question('are you sure? ', r=>main.next(r))        

  // readline boilerplate
  rl.close()

  console.log(answerA, answerB)

})()  // <-- executed: iterator created from generator
main.next()     // kick off the iterator, 
                // runs until the first 'yield', including rightmost code
                // and waits until another main.next() happens

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

Давайте посмотрим на пример: Предположим, вы используете некую структуру, которая является точкой входа в ваше приложение (вы не можете изменить эту структуру). Эта структура загружает модули nodejs как плагины и вызывает некоторые методы в плагинах. Допустим, эта структура принимает только синхронные функции и не использует сами по себе волокна.

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

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

Оборотная сторона: если фреймворк внутренне использует setTimeout или Promises, он выйдет из контекста волокна. Это можно обойти, высмеивая setTimeout, Promise.then и все обработчики событий.

Вот как вы можете отдавать волокно, пока не будет разрешено Promise. Этот код принимает асинхронную функцию (возврат обещания) и возобновляет работу волокна, когда обещание разрешено:

framework-entry.js

console.log(require("./my-plugin").run());

async-lib.js

exports.getValueAsync = () => {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve("Async Value");
    }, 100);
  });
};

my-plugin.js

const Fiber = require("fibers");

function fiberWaitFor(promiseOrValue) {
  var fiber = Fiber.current, error, value;
  Promise.resolve(promiseOrValue).then(v => {
    error = false;
    value = v;
    fiber.run();
  }, e => {
    error = true;
    value = e;
    fiber.run();
  });
  Fiber.yield();
  if (error) {
    throw value;
  } else {
    return value;
  }
}

const asyncLib = require("./async-lib");

exports.run = () => {
  return fiberWaitFor(asyncLib.getValueAsync());
};

my-entry.js

require("fibers")(() => {
  require("./framework-entry");
}).run();

При запуске node framework-entry.js будет выдана ошибка: Error: yield() called with no fiber running. Если вы запустите node my-entry.js, он работает должным образом.

Вам следует смотреть не на то, что происходит вокруг вызова, создающего волокно, а скорее на то, что происходит внутри волокна. Как только вы окажетесь внутри волокна, вы можете программировать в стиле синхронизации. Например:

function f1() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);   
}

function f2() {
    f1();
    f1();
}

Fiber(function() {
    f2();
}).run();

Внутри волокна вы вызываете f1, f2 и sleep, как если бы они были синхронизированы.

В типичном веб-приложении вы создадите Fiber в диспетчере HTTP-запросов. Как только вы это сделаете, вы можете написать всю свою логику обработки запросов в стиле синхронизации, даже если она вызывает асинхронные функции (fs, базы данных и т. Д.).

Синхронизация кода Node.js важна в нескольких аспектах, таких как база данных. Но реальное преимущество Node.js заключается в асинхронном коде. Поскольку это однопоточный неблокирующий.

мы можем синхронизировать его, используя важные функции Fiber () Используйте await () и defer (), мы вызываем все методы, используя await (). затем замените функции обратного вызова на defer ().

Обычный асинхронный код, использующий функции обратного вызова.

function add (var a, var b, function(err,res){
       console.log(res);
});

 function sub (var res2, var b, function(err,res1){
           console.log(res);
    });

 function div (var res2, var b, function(err,res3){
           console.log(res3);
    });

Синхронизируйте приведенный выше код с помощью Fiber (), await () и defer ()

fiber(function(){
     var obj1 = await(function add(var a, var b,defer()));
     var obj2 = await(function sub(var obj1, var b, defer()));
     var obj3 = await(function sub(var obj2, var b, defer()));

});

Я надеюсь, это поможет. Спасибо

Сначала я боролся с этим с помощью node.js, а async.js - лучшая библиотека, которую я нашел, чтобы помочь вам справиться с этим. Если вы хотите писать синхронный код с помощью узла, подход следующий.

var async = require('async');

console.log('in main');

doABunchOfThings(function() {
  console.log('back in main');
});

function doABunchOfThings(fnCallback) {
  async.series([
    function(callback) {
      console.log('step 1');
      callback();
    },
    function(callback) {
      setTimeout(callback, 1000);
    },
    function(callback) {
      console.log('step 2');
      callback();
    },
    function(callback) {
      setTimeout(callback, 2000);
    },
    function(callback) {
      console.log('step 3');
      callback();
    },
  ], function(err, results) {
    console.log('done with things');
    fnCallback();
  });
}

эта программа ВСЕГДА будет производить следующее ...

in main
step 1
step 2
step 3
done with things
back in main

Javascript - это однопоточный язык, вы не хотите блокировать весь свой сервер! Асинхронный код устраняет условия гонки, делая зависимости явными.

Научитесь любить асинхронный код!

Взгляните на promises для асинхронного кода без создания пирамиды ада обратного вызова. Я рекомендую библиотеку PromiseQ для node.js

httpGet(url.parse("http://example.org/")).then(function (res) {
    console.log(res.statusCode);  // maybe 302
    return httpGet(url.parse(res.headers["location"]));
}).then(function (res) {
    console.log(res.statusCode);  // maybe 200
});

http://howtonode.org/promises

РЕДАКТИРОВАТЬ: это, безусловно, мой самый спорный ответ, теперь у узла есть ключевое слово yield, которое позволяет обрабатывать асинхронный код, как если бы он был синхронным. http://blog.alexmaccaw.com/how-yield-will-transform-node