Як перетворити виклики функції асинхронізації у функцію синхронізації в Node.js або Javascript?

Припустимо, ви підтримуєте бібліотеку, яка відкриває функцію getData. Ваші користувачі називають його , щоб отримати фактичні дані:
var output = getData();
Під дані Ковпак зберігаються в файлі , так що ви реалізовані з getDataдопомогою Node.js вбудованої fs.readFileSync. Це очевидно і те, getDataі fs.readFileSyncфункції синхронізації. Одного разу вам сказали переключити базове джерело даних на репо, наприклад MongoDB, до якого можна отримати доступ лише асинхронно. Вам також сказали, щоб не дратувати користувачів, getDataAPI не можна змінювати, щоб повернути лише обіцянку або вимагати параметр зворотного виклику. Як ви відповідаєте обом вимогам?

Асинхронною функцією, що використовує зворотній зв'язок / обіцянку, є ДНК JavasSript і Node.js. Будь-який нетривіальний додаток JS, ймовірно, пронизаний цим стилем кодування. Але ця практика може легко призвести до так званої піраміди зворотного виклику приреченості. Ще гірше, якщо будь-який код будь-якого абонента в ланцюзі викликів залежить від результату функції асинхронізації, цей код також повинен бути включений у функцію зворотного виклику, накладаючи обмеження стилю кодування на абонента. Час від часу я знаходжу необхідність інкапсулювати функцію асинхронізації (часто надану у сторонній бібліотеці) у функцію синхронізації, щоб уникнути масового глобального пере-факторингу. Пошук рішення на цю тему зазвичай закінчувався за допомогою волокон Nodeабо npm-пакети, отримані з нього. Але Волокна просто не можуть вирішити проблему, з якою я стикаюся. Навіть приклад, поданий автором Волокна, ілюстрував недолік:

...
Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

Фактичний вихід:

wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
back in main
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)

Якщо функція Fiber дійсно перетворює функцію сну функції асинхронізації в синхронізацію, вихід повинен бути:

wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)
back in main

Я створив ще один простий приклад в JSFiddle і шукав код, щоб отримати очікуваний вихід. Я прийму рішення, яке працює лише в Node.js, тому ви можете вимагати будь-якого пакету npm, незважаючи на те, що не працюєте в JSFiddle.

deasync перетворює функцію async в синхронізацію, реалізовану за допомогою механізму блокування, викликаючи цикл подій 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

Якщо функція Fiber дійсно перетворює функцію сну асинхронізації в режим синхронізації

Так. Всередині волокна функція чекає перед входом у систему ok. Волокна не роблять функції асинхронізації синхронними, але дозволяють записувати синхронно виглядає код, який використовує функції асинхронізації, а потім буде запускатися асинхронно всередині а Fiber.

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

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

Моя мета - мінімізувати вплив на абонента, коли метод збору даних змінюється з синхронізації на асинхронізацію

І обіцянки, і волокна можуть це зробити.

Ви повинні використовувати обіцянки:

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 не є асинхронізуванням, незважаючи на виклик функції асинхронізації.

EDIT: Я розумію, що багато разів вам потрібно ввімкнути функцію асинхронізації в функцію синхронізації, яка знаходиться всередині контролера. Для таких ситуацій, ось фокус партії:

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, де я визначив зворотній дзвінок, і випромініть подію, де я викликав зворотний виклик.

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

Розглянемо приклад: Скажімо, ви використовуєте деякий фреймворк, який є точкою входу вашої програми (ви не можете змінювати цю рамку). Цей фреймворк завантажує модулі 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це працює, як очікувалося.

Здійснення синхронізації коду Node.js є важливим у кількох аспектах, таких як база даних. Але фактична перевага Node.js полягає в асинхронному коді. Так як це однониткове неблокування.

ми можемо синхронізувати його за допомогою важливої ​​функціональності Fiber () Використовуйте await () та defer (), ми називаємо всі методи за допомогою await () потім замініть функції зворотного виклику на defer ().

Нормальний код Async. Це використовує функції CallBack.

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 (), wait () та 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()));

});

Сподіваюся, це допоможе. Спасибі

В даний час ця модель генератора може бути рішенням у багатьох ситуаціях.

Ось приклад послідовних запитів консолі в 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

Ви не повинні дивитися на те, що відбувається навколо дзвінка, який створює волокно, а на те, що відбувається всередині волокна. Після того, як ви перебуваєте всередині волокна, ви можете програмувати в стилі синхронізації. Наприклад:

функція f1 () {
    console.log ('зачекати ...' + нова дата);
    сон (1000);
    console.log ('ok ...' + нова дата);   
}

функція f2 () {
    f1 ();
    f1 ();
}

Волокна (функція () {
    f2 ();
}). run ();

Усередині волокна, яке ви називаєте f1, f2і sleepніби вони синхронізуються.

У звичайному веб-додатку ви створите Fiber у своєму диспетчері запитів HTTP. Після того, як ви зробите це, ви зможете записати всю логіку обробки запиту в стилі синхронізації, навіть якщо вона викликає функції асинхронізації (fs, бази даних тощо).

Спочатку я боровся з цим з 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асинхронний код, не створюючи піраміди пекла зворотного дзвінка. Я рекомендую бібліотеку promisQ для 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

EDIT: це, безумовно, моя найсуперечливіша відповідь, у вузлі зараз є ключове слово "вихід", яке дозволяє розглядати код асинхронізації як би синхронним. http://blog.alexmaccaw.com/how-yield-will-transform-node