Cómo envolver llamadas a funciones asincrónicas en una función de sincronización en el nodo.js o Javascript?

También hay un módulo de sincronización npm. que se utiliza para sincronizar el proceso de ejecución de la consulta.

Cuando desea ejecutar consultas paralelas de manera sincrónica, entonces node restrict para hacerlo porque nunca espera la respuesta. y el módulo de sincronización es muy perfecto para ese tipo de solución.

Código de muestra

/*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);
                }
            });
        });
    }

Enlace de Referencia: https://www.npmjs.com/package/sync

Si la función de fibra realmente convierte la función asincrónica sleep en sync

Sí. Dentro de la fibra, la función espera antes de registrar ok. Las fibras no hacen que las funciones asíncronas sean síncronas, sino que permiten escribir código de aspecto síncrono que utiliza funciones asíncronas y luego se ejecutará de forma asíncrona dentro de un Fiber.

De vez en cuando encuentro la necesidad de encapsular una función asincrónica en una función de sincronización con el fin de evitar la masiva global re-factorización.

No puedes. Es imposible hacer que el código asíncrono sea síncrono. Tendrá que anticiparse a eso en su código global y escribirlo en estilo asíncrono desde el principio. Ya sea que envuelva el código global en una fibra, use promesas, generadores de promesas o simples devoluciones de llamada depende de sus preferencias.

Mi objetivo es minimizar el impacto en la persona que llama cuando el método de adquisición de datos se cambia de sync a async

Ambas promesas y fibras puedo hacer eso.

No deberías mirar lo que sucede alrededor de la llamada que crea la fibra, sino más bien lo que sucede dentro de la fibra. Una vez que esté dentro de la fibra, puede programar en estilo de sincronización. Por ejemplo:

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

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

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

Dentro de la fibra que llamas f1, f2 y sleep como si estuvieran sincronizados.

En una aplicación web típica, creará la fibra en su despachador de solicitudes HTTP. Una vez que lo hayas hecho, puedes escribir toda tu lógica de manejo de solicitudes en estilo de sincronización, incluso si llama a funciones asincrónicas(fs, bases de datos, etc.).

Haciendo Nodo.la sincronización de código js es esencial en algunos aspectos como la base de datos. Pero la ventaja real de Nodo.js se encuentra en código asíncrono. Ya que es de un solo hilo sin bloqueo.

Podemos sincronizarlo usando Fibra de funcionalidad importante() Usar await () y diferir () llamamos a todos los métodos usando await (). luego reemplace las funciones de devolución de llamada con defer ().

Código asíncrono normal.Esto utiliza funciones de devolución de llamada.

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);
    });

Sincroniza el código anterior usando Fiber(), await() y 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()));

});

Espero esto ayudará. Gracias

No puedo encontrar un escenario que no se pueda resolver usando fibras de nodo. El ejemplo que proporcionó usando node-fibers se comporta como se espera. La clave es ejecutar todo el código relevante dentro de una fibra, para que no tenga que iniciar una nueva fibra en posiciones aleatorias.

Veamos un ejemplo: Digamos que usas algún framework, que es el punto de entrada de tu aplicación (no puedes modificar este framework). Este framework carga módulos nodejs como plugins, y llama a algunos métodos en los plugins. Digamos que este marco solo acepta funciones síncronas, y no utiliza fibras por sí mismo.

Hay una biblioteca que quieres usar en uno de tus plugins, pero esta biblioteca es asincrónica, y tampoco quieres modificarla.

El hilo principal no se puede producir cuando no se está ejecutando ninguna fibra, ¡pero aún puede crear complementos utilizando fibras! Simplemente cree una entrada de envoltura que inicie todo el marco dentro de una fibra, para que pueda obtener la ejecución desde el plugin.

Inconveniente: Si el marco utiliza setTimeout o Promises internamente, entonces escapará al contexto de fibra. Esto se puede resolver burlándose setTimeout, Promise.then, y todos los controladores de eventos.

Así que así es como puedes producir una fibra hasta que se resuelva un Promise. Este código toma una función async (Promise returning) y reanuda la fibra cuando la promesa es resuelto:

Marco-entrada.js

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

Async-lib.js

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

Mi-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());
};

Mi entrada.js

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

Cuando ejecutas node framework-entry.js lanzará un error: Error: yield() called with no fiber running. Si ejecuta node my-entry.js funciona como se espera.

Tienes que usar promesas:

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);
    });
}

Me gustan más las definiciones de funciones de flecha. Pero cualquier cadena de la forma" () = > {...} "también podría escribirse como" function () {...}"

Así que topDog no es async a pesar de llamar a una función async.

EDITAR: Me doy cuenta de que muchas de las veces que necesita envolver una función asincrónica dentro de una función de sincronización está dentro de un controlador. Para esas situaciones, aquí hay un truco de fiesta:

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.
}

Utilizando esto con callbacks, puedes hacer un wrap que no use promesas:

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)
    })()
}

Aplicando este truco a un EventEmitter, puedes obtener los mismos resultados. Definir el oyente del EventEmitter donde he definido la devolución de llamada, y emitir el evento donde llamé a la devolución de llamada.

Hoy en día este patrón generador puede ser una solución en muchas situaciones.

Aquí un ejemplo de instrucciones de consola secuenciales en nodejs usando async readline.función de pregunta:

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

Luché con esto al principio con node.js y async.js es la mejor biblioteca que he encontrado para ayudarte a lidiar con esto. Si desea escribir código síncrono con node, el enfoque es de esta manera.

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();
  });
}

Este programa SIEMPRE producirá lo siguiente...

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

Javascript es un único lenguaje de subprocesos, ¡no quieres bloquear todo tu servidor! El código asincrónico elimina las condiciones de carrera al hacer explícitas las dependencias.

¡Aprende a amar el código asíncrono!

Echa un vistazo a promises para el código asincrónico sin crear una pirámide de infierno de devolución de llamada. Recomiendo la biblioteca promiseQ para 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

EDITAR: esta es, con mucho, mi respuesta más controvertida, node ahora tiene la palabra clave yield, que le permite tratar el código asíncrono como si fuera sychronous. http://blog.alexmaccaw.com/how-yield-will-transform-node