2016-08-18 7 views
0

Ich habe begonnen, Runde mit Node.js zu spielen, aber ich habe Probleme mit asynchronen Funktionen Ich konnte ein Spiel kleines Spiel machen. Aber die einzige Möglichkeit, die asynchronen Funktionen mit den synchronen Funktionen arbeiten zu lassen, war die Verwendung globaler Variablen.Mischen von asynchronen Funktionen mit synchronen Funktionen?

Beispiel

var promptly = require("./promptly"); //needed for input {npm install promptly} 
var firstName; 
var lastName; 

GetFirstName(); 

function GetFirstName() { //asynchronous function 
    promptly.prompt('You first name: ', function (err,value) { 
     firstName = value; 
     getLastName(); 
    }); 
} 

function getLastName() { //asynchronous function 
    promptly.prompt('You last name: ', function (err,value) { 
     lastName = value; 
     printName(); 
    }); 
} 

function printName() { //synchronous function 
    console.log(firstName+" "+lastName); 
} 

Das funktioniert aber mein kleines Spiel mit 5 asynchroner Funktion endete mit 14 globalen Variablen. also meine Frage ist, was ist der richtige Weg, so etwas zu tun?

+3

Es sollte keine globalen Variablen geben. Wissen Sie, Argumente an Funktionen zu übergeben? So übergeben Sie Informationen von einem Kontext an eine andere Funktion, ohne globale Variablen zu verwenden. Dies ist ein sehr einfaches Programmierkonzept, so dass es sehr hilfreich für Sie sein kann, einem Online-Tutorial zu Grundlagen der Programmierung zu folgen, anstatt nur Code ohne entsprechendes Training zu schreiben. – jfriend00

+1

Informieren Sie sich über Versprechungen, das ist der richtige Weg, asynchrone Funktionen zu verwenden, wie sie synchron waren. Überprüfen Sie f.i.Dieser Link über den Punkt der Versprechen: https://gist.github.com/domenic/3889970. Das Aufrufen von asynchronen Funktionen in Callbacks asynchroner Funktionen führt zu Callback-Hells und ist keine solide Methode, generischen, testbaren und wiederverwendbaren Code zu erstellen. BEARBEITEN: tatsächlich die @ Brandon Antwort bekommt den Punkt – Sergeon

+0

Ich verstehe, dass es keine globalen Variablen geben sollte, die ich über das Übergeben von Argumenten an Funktionen weiß. Das Problem ist, ich habe viele Funktionen, die eine Variable erhalten, die zu einer Funktion fünf Funktion auf der ganzen Linie gehen müssen, es muss einen besseren Weg geben, anstatt diese Variable an 4 Funktion zu übergeben, die es nie verwenden wird. – Ashlin

Antwort

1

Was @ jfriend00 bezieht sich auf den in ihren/seinen Kommentar ist, dass, wenn Sie eine Funktion definieren, können Sie parameters definieren, dass die Funktion übernehmen soll.

, die mit im Auge, können Sie Ihren Code so etwas wie dieses umschreiben:

var promptly = require("./promptly"); //needed for input {npm install promptly} 


GetFirstName(); 

function GetFirstName() { //asynchronous function 
    promptly.prompt('You first name: ', function (err,firstName) { 

     getLastName(firstName); 
    }); 
} 

function getLastName(firstName) { //asynchronous function 
    promptly.prompt('You last name: ', function (err,lastName) { 

     printName(firstName, lastName); 
    }); 
} 

function printName(firstName, lastName) { //synchronous function 
    console.log(firstName+" "+lastName); 
} 

Beachten Sie, dass jede ‚Stufe‘ des Prozesses das Ergebnis aus der vorherige ‚Stufe‘ akzeptiert.

Die Asynchron-Technik, die Sie verwenden als callback hell liebevoll genannt, wie die callback s (das heißt die functions Sie vorbei an .prompt() als zweites Argument) dazu neigen, zu nisten tief & schnell unüberschaubar.

Javascript hat in diesen Tagen viele Lösungen, um dieses Problem zu lösen. Sobald Sie den "Fluss" eines Async-Programms verstehen, empfehle ich Ihnen, einige der benutzerfreundlicheren Optionen zu betrachten (nehmen Sie meine Snippets mit einer Prise Salz, sie sollen nur Konzepte veranschaulichen):

async.js - diese Bibliothek hat viele große Dienstprogramme, die Sie Rückrufe in lesbarer Weise schreiben helfen:

async.series([ 
    asyncFunction1(arg, callback) { 
    // code 
    callback() 
    }, 
    asyncFunction2(arg, callback) { 
    // code 
    callback() 
    }, 
    asyncFunction3(arg, callback) { 
    // code 
    callback() 
    } 
] 

Promises - eine neue Funktion in Javascript und eine bereits von Bibliotheken unterstützt. Unter der Haube sind diese interessant, aber in der Praxis lassen sie einfach für sauberere Code und Fehlerbehandlung:

asyncFunction1(args) { 
    // code 
    return x 
} 
.then(asyncFunction2(x) { 
    // code 
    return y 
}) 
.then(asyncFunction3(y) { 
    // code 
    return z 
}) 

async/await - eine der neuesten Versuche, die Asynchron-Code Herausforderung zu lösen. Persönlich habe ich sie noch nicht benutzt, aber die Beispiele sind interessant.

Der letzte Artikel, den ich verlinkt habe, ist definitiv eine Lektüre wert, um einen guten Überblick über die asynchrone Herausforderung zu erhalten. Es ist kein einfaches Konzept, aber sobald es klickt, ist es ziemlich intuitiv.

+0

FWIW das ist KEINE Callback-Hölle. Dies ist die LÖSUNG zur Callback-Hölle: um die Funktionen separat zu definieren anstatt zu verschachteln. – slebetman

0

Pass firstName in getLastName() und dann firstName und lastName in printName() passieren. Hier einige Beispiel-Code:

var promptly = require("promptly"); 
GetFirstName(); 

function GetFirstName() { 
    promptly.prompt('You first name: ', function (err,value) { 
    getLastName(value); 
    }); 
} 

function getLastName(firstName) { 
    promptly.prompt('You last name: ', function (err,value) { 
    printName(firstName, value); 
    }); 
} 

function printName(firstName, lastName) { 
    console.log(firstName + " " + lastName); 
} 
Verwandte Themen