Come scrivere funzioni asincrone per Node.js

Ho provato a ricercare come scrivere esattamente le funzioni asincrone. Dopo aver esaminato un sacco di documentazione, non mi è ancora chiaro.

Come si scrivono funzioni asincrone per Node? Come devo implementare correttamente la gestione degli eventi di errore?

Un altro modo per porre la mia domanda sarebbe questo: come devo interpretare la seguente funzione?

var async_function = function(val, callback){
    process.nextTick(function(){
        callback(val);
    });
};

Inoltre, ho trovato interessante questa domanda su SO ("Come creo una funzione asincrona non bloccante in node.js?"). Non mi sembra che abbia ancora ricevuto una risposta.

Sembra che tu stia confondendo l'IO asincrono con le funzioni asincrone. node.js utilizza l'IO non bloccante asincrono perché l'IO non bloccante è migliore. Il modo migliore per capirlo è guardare alcuni video di ryan dahl.

Come si scrivono funzioni asincrone per Node?

Basta scrivere normali funzioni, l'unica differenza è che non vengono eseguite immediatamente ma passate come callback.

Come devo implementare correttamente la gestione degli eventi di errore

Generalmente le API ti danno un callback con un errore come primo argomento. Per esempio

database.query('something', function(err, result) {
  if (err) handle(err);
  doSomething(result);
});

È un modello comune.

Un altro modello comune è on('error'). Per esempio

process.on('uncaughtException', function (err) {
  console.log('Caught exception: ' + err);
});

Modificare:

var async_function = function(val, callback){
    process.nextTick(function(){
        callback(val);
    });
};

La funzione di cui sopra quando viene chiamata come

async_function(42, function(val) {
  console.log(val)
});
console.log(43);

Verrà stampato 42sulla console in modo asincrono. In particolare process.nextTicksi attiva dopo che il callstack di eventloop corrente è vuoto. Quello stack di chiamate è vuoto dopo async_functione console.log(43)sono stati eseguiti. Quindi stampiamo 43 seguito da 42.

Probabilmente dovresti leggere un po 'sul ciclo degli eventi.

Il solo passaggio di callback non è sufficiente. Devi usare settimer per esempio, per rendere la funzione asincrona.

Esempi: funzioni non asincrone:

function a() {
  var a = 0;    
  for(i=0; i<10000000; i++) {
    a++;
  };
  b();
};

function b() {
  var a = 0;    
  for(i=0; i<10000000; i++) {
    a++;
  };    
  c();
};

function c() {
  for(i=0; i<10000000; i++) {
  };
  console.log("async finished!");
};

a();
console.log("This should be good");

Se eseguirai l'esempio sopra, questo dovrebbe essere buono, dovrai aspettare fino a quando quelle funzioni finiranno di funzionare.

Funzioni pseudo multithread (asincrone):

function a() {
  setTimeout ( function() {
    var a = 0;  
    for(i=0; i<10000000; i++) {
      a++;
    };
    b();
  }, 0);
};

function b() {
  setTimeout ( function() {
    var a = 0;  
    for(i=0; i<10000000; i++) {
      a++;
    };  
    c();
  }, 0);
};

function c() {
  setTimeout ( function() {
    for(i=0; i<10000000; i++) {
    };
    console.log("async finished!");
  }, 0);
};

a();
console.log("This should be good");

Questo sarà veramente asincrono. Questo dovrebbe essere buono verrà scritto prima del termine dell'asincronia.

Dovresti guardare questo: episodio 19 di Node Tuts - Asynchronous Iteration Patterns

Dovrebbe rispondere alle tue domande.

Se SAPETE che una funzione restituisce una promessa, suggerisco di utilizzare le nuove funzionalità async / await in JavaScript. Rende la sintassi sincrona ma funziona in modo asincrono. Quando aggiungi la asyncparola chiave a una funzione, ti consente di fare awaitpromesse in tale ambito:

async function ace() {
  var r = await new Promise((resolve, reject) => {
    resolve(true)
  });

  console.log(r); // true
}

se una funzione non restituisce una promessa, ti consiglio di racchiuderla in una nuova promessa che definisci, quindi risolvi i dati che desideri:

function ajax_call(url, method) {
  return new Promise((resolve, reject) => {
    fetch(url, { method })
    .then(resp => resp.json())
    .then(json => { resolve(json); })
  });
}

async function your_function() {
  var json = await ajax_call('www.api-example.com/some_data', 'GET');
  console.log(json); // { status: 200, data: ... }
}

Conclusione: sfruttare il potere delle promesse.

Prova questo, funziona sia per il nodo che per il browser.

isNode = (typeof exports !== 'undefined') &&
(typeof module !== 'undefined') &&
(typeof module.exports !== 'undefined') &&
(typeof navigator === 'undefined' || typeof navigator.appName === 'undefined') ? true : false,
asyncIt = (isNode ? function (func) {
  process.nextTick(function () {
    func();
  });
} : function (func) {
  setTimeout(func, 5);
});

Ho occupato troppe ore per questo compito in node.js. Sono principalmente un ragazzo front-end.

Lo trovo abbastanza importante, perché tutti i metodi dei nodi asincroni si occupano di callback e trasformarlo in Promise è meglio gestirlo.

Voglio solo mostrare un possibile risultato, più snello e leggibile. Usando ECMA-6 con async puoi scriverlo in questo modo.

 async function getNameFiles (dirname) {
  return new Promise((resolve, reject) => {
    fs.readdir(dirname, (err, filenames) => {
      err !== (undefined || null) ? reject(err) : resolve(filenames)
    })
  })
}

la (undefined || null)è per Repl scenari (lettura evento ciclo di stampa), usando il lavoro non definito anche.