Jak zawijać wywołania funkcji asynchronicznej w funkcję synchronizacji w Node.js lub Javascript?

Załóżmy, że utrzymujesz bibliotekę, która ujawnia funkcję getData. Użytkownicy nazwać uzyskać rzeczywiste dane:
var output = getData();
Pod kaptur dane są zapisywane w pliku, dzięki czemu realizowane getDataprzy użyciu node.js wbudowanej fs.readFileSync. To oczywiste, że zarówno getDatai fs.readFileSyncsą funkcjami synchronizacji. Pewnego dnia powiedziano Ci, aby przełączyć bazowe źródło danych do repozytorium, takiego jak MongoDB, do którego można uzyskać dostęp tylko asynchronicznie. Powiedziano ci również, abyś nie wkurzał swoich użytkowników, getDataAPI nie może zostać zmienione tak, aby zwracało jedynie obietnicę lub wymagało parametru wywołania zwrotnego. Jak spełniasz oba wymagania?

Funkcja asynchroniczna wykorzystująca wywołanie zwrotne / obietnicę to DNA języków JavasSript i Node.js. Każda nietrywialna aplikacja JS jest prawdopodobnie przesiąknięta tym stylem kodowania. Ale ta praktyka może łatwo doprowadzić do tak zwanej piramidy zagłady. Co gorsza, jeśli jakikolwiek kod w jakimkolwiek obiekcie wywołującym w łańcuchu wywołań zależy od wyniku funkcji asynchronicznej, ten kod również musi zostać opakowany w funkcję wywołania zwrotnego, nakładając na wywołującego ograniczenie stylu kodowania. Od czasu do czasu potrzebuję hermetyzowania funkcji asynchronicznej (często dostarczanej w bibliotece innej firmy) w funkcję synchronizacji, aby uniknąć masowego globalnego ponownego fakturowania. Poszukiwanie rozwiązania na ten temat zwykle kończyło się na Node Fiberslub pakiety npm pochodzące z niego. Ale włókna po prostu nie mogą rozwiązać problemu, z którym mam do czynienia. Nawet przykład podany przez autora Fibersa ilustruje brak:

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

Rzeczywista wydajność:

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)

Jeśli funkcja Fiber naprawdę zmienia uśpienie funkcji asynchronicznej w synchronizację, wynik powinien wyglądać następująco:

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

Stworzyłem kolejny prosty przykład w JSFiddle i szukam kodu, który zapewni oczekiwane wyniki. Przyjmuję rozwiązanie, które działa tylko w Node.js, więc możesz wymagać dowolnego pakietu npm, mimo że nie działa w JSFiddle.

deasync zamienia funkcję asynchroniczną w synchronizację, zaimplementowaną z mechanizmem blokującym, wywołując pętlę zdarzeń Node.js w warstwie JavaScript. W rezultacie deasync blokuje tylko kolejny kod przed uruchomieniem, bez blokowania całego wątku ani konieczności oczekiwania na zajętość. W tym module jest odpowiedź na wyzwanie 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)

(zastrzeżenie: jestem współautorem deasync. Moduł został utworzony po wysłaniu tego pytania i nie znalazł żadnej działającej propozycji.)

Istnieje również moduł synchronizacji npm. który służy do synchronizacji procesu wykonywania zapytania.

Jeśli chcesz uruchamiać zapytania równoległe w sposób synchroniczny, ogranicz węzeł, aby to zrobić, ponieważ nigdy nie czeka na odpowiedź. i moduł synchronizacji jest doskonały do ​​tego rodzaju rozwiązań.

Przykładowy kod

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

odnośnik referencyjny: https://www.npmjs.com/package/sync

Jeśli funkcja Fiber naprawdę zmienia uśpienie funkcji asynchronicznej w synchronizację

Tak. Wewnątrz włókna funkcja czeka przed zalogowaniem ok. Włókna nie sprawiają, że funkcje asynchroniczne są synchroniczne, ale pozwalają na pisanie kodu wyglądającego synchronicznie, który używa funkcji asynchronicznych, a następnie będzie działać asynchronicznie wewnątrz pliku Fiber.

Od czasu do czasu odkrywam potrzebę hermetyzowania funkcji asynchronicznej w funkcję synchronizacji, aby uniknąć masowego globalnego ponownego fakturowania.

Nie możesz. Niemożliwe jest synchronizowanie kodu asynchronicznego. Będziesz musiał przewidzieć to w swoim kodzie globalnym i od początku napisać go w stylu asynchronicznym. To, czy zawiniesz globalny kod we włókno, użyjesz obietnic, generatorów obietnic czy prostych wywołań zwrotnych, zależy od twoich preferencji.

Moim celem jest zminimalizowanie wpływu na dzwoniącego, gdy metoda pozyskiwania danych zostanie zmieniona z synchronizacji na asynchroniczną

Mogą to zrobić zarówno obietnice, jak i włókna.

Musisz korzystać z obietnic:

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

Bardziej lubię definicje funkcji strzałek. Ale dowolny ciąg w postaci „() => {...}” można również zapisać jako „funkcja () {...}”

Zatem topDog nie jest asynchroniczny pomimo wywołania funkcji asynchronicznej.

EDYCJA: Zdaję sobie sprawę, że wiele razy trzeba zawinąć funkcję asynchroniczną wewnątrz funkcji synchronizacji, gdy znajduje się wewnątrz kontrolera. Oto sztuczka imprezowa w takich sytuacjach:

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

Wykorzystując to z wywołaniami zwrotnymi, możesz wykonać zawijanie, które nie używa obietnic:

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

Stosując tę ​​sztuczkę do EventEmittera, możesz uzyskać te same wyniki. Zdefiniuj odbiornik EventEmittera, w którym zdefiniowałem wywołanie zwrotne, i wyemituj zdarzenie, w którym wywołałem wywołanie zwrotne.

Nie mogę znaleźć scenariusza, którego nie można rozwiązać za pomocą włókien węzłowych. Podany przykład przy użyciu węzłów-włókien zachowuje się zgodnie z oczekiwaniami. Kluczem jest uruchomienie całego odpowiedniego kodu wewnątrz światłowodu, więc nie trzeba rozpoczynać nowego włókna w przypadkowych pozycjach.

Zobaczmy przykład: Załóżmy, że używasz jakiegoś frameworka, który jest punktem wejścia do twojej aplikacji (nie możesz modyfikować tego frameworka). Ten framework ładuje moduły nodejs jako wtyczki i wywołuje niektóre metody we wtyczkach. Powiedzmy, że ten framework akceptuje tylko funkcje synchroniczne i sam nie używa włókien.

Istnieje biblioteka, której chcesz użyć w jednej ze swoich wtyczek, ale ta biblioteka jest asynchroniczna i nie chcesz jej też modyfikować.

Nie można uzyskać głównego wątku, gdy żadne włókno nie jest uruchomione, ale nadal można tworzyć wtyczki za pomocą włókien! Po prostu utwórz wpis opakowujący, który uruchamia cały framework wewnątrz włókna, abyś mógł wykonać wykonanie z wtyczek.

Wada: Jeśli platforma używa setTimeoutlubPromise s wewnętrznie, to wymknie się z kontekstu włókna. Można to obejść przez szyderczy setTimeout, Promise.theni wszyscy obsługi zdarzeń.

Więc w ten sposób możesz wydobyć włókno do czasu Promise zostanie rozwiązane. Ten kod przyjmuje funkcję asynchroniczną (zwracająca obietnicę) i wznawia działanie włókna po rozwiązaniu obietnicy:

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

Po uruchomieniu node framework-entry.jsgo wygeneruje błąd: Error: yield() called with no fiber running. Jeśli uruchomisz node my-entry.js, działa zgodnie z oczekiwaniami.

Synchronizacja kodu Node.js jest niezbędna w kilku aspektach, takich jak baza danych. Jednak faktyczna zaleta Node.js polega na kodzie asynchronicznym. Ponieważ jest to jeden wątek nieblokujący.

możemy go zsynchronizować używając ważnej funkcjonalności Fibre () Używając await () i defer () wywołujemy wszystkie metody używając await (). następnie zamień funkcje zwrotne na defer ().

Normalny kod asynchroniczny, który wykorzystuje funkcje 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);
    });

Zsynchronizuj powyższy kod za pomocą Fiber (), await () i 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()));

});

Mam nadzieję, że to pomoże. Dziękuję Ci

Obecnie ten wzorzec generatora może być rozwiązaniem w wielu sytuacjach.

Oto przykład sekwencyjnych monitów konsoli w nodejs używających funkcji 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

Nie powinieneś patrzeć na to, co dzieje się wokół połączenia, które tworzy włókno, ale raczej na to, co dzieje się wewnątrz włókna. Gdy jesteś w środku włókna, możesz programować w stylu synchronizacji. Na przykład:

function f1 () {
    console.log ('czekaj ...' + nowa data);
    spać (1000);
    console.log ('ok ...' + nowa data);   
}

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

Fiber (function () {
    f2 ();
}).biegać();

Wewnątrz włókna, do którego dzwonisz f1, f2i sleepjakby były zsynchronizowane.

W typowej aplikacji internetowej światłowód zostanie utworzony w programie wysyłającym żądania HTTP. Gdy już to zrobisz, możesz napisać całą logikę obsługi żądań w stylu synchronizacji, nawet jeśli wywołuje ona funkcje asynchroniczne (FS, bazy danych itp.).

Na początku zmagałem się z tym, korzystając z node.js, a async.js to najlepsza biblioteka, jaką znalazłem, aby pomóc ci sobie z tym poradzić. Jeśli chcesz pisać kod synchroniczny z węzłem, podejście jest takie.

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

ten program ZAWSZE wyprodukuje następujące ...

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

Javascript jest językiem jednowątkowym, nie chcesz blokować całego serwera! Kod asynchroniczny eliminuje warunki wyścigu, jawnie określając zależności.

Naucz się kochać kod asynchroniczny!

Przyjrzyj się promisesasynchronicznemu kodowi bez tworzenia piramidy piekła zwrotnego. Polecam bibliotekę promiseQ dla 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

EDYCJA: to jest zdecydowanie moja najbardziej kontrowersyjna odpowiedź, węzeł ma teraz słowo kluczowe yield, które pozwala traktować kod asynchroniczny tak, jakby był synchroniczny. http://blog.alexmaccaw.com/how-yield-will-transform-node