Javascript Node. Wie bekomme ich hier einen return hin

[Martin M. (ats3788)]

Hallo
ich spiele ein wenig mit JavaScript Node herum leider
bekomme ich nur ein undentified zurück, warum das so ist habe ich schon 
herausgefunden.

 

module.exports = {

    query_database : function(query, SQL_ID,       )
{

  
    //"select distinct * from main"
    connection.query(query, function(err, recordsArray, fields) {
          if (err) {
            console.log("Error occured while fetching the data - module database !!")
        } else {
          
           var jsonStr = JSON.stringify(recordsArray); // Important Make a Sting fom an Object we get 
            
          const objJson = JSON.parse(jsonStr);
 
           const myfunction = require("../myfunctions/myfunctions");   
           const  obj = myfunction.fetch_Json(objJson, SQL_ID); // Here I get a specific Dataset
            console.log(obj); // Here I het my Json Object

            return(obj); //return is undentified because a function in a function
       
          }
        
       })
       
      }
  }

eine function in einer function

bei einer einfachen function kein Problem

https://stackoverflow.com/questions/52346981/create-callback-in-node-js-module-exports
Ich müßte der funktion query_database den Wert übergeben , nur wie ist 
die Frage

[Εrnst B. (ernst)]

Dein Problem ist weniger die function in der function, dein Problem ist 
die Asynchrone Arbeitsweise deines "DB"-Moduls.

Aus der Äusseren Funktion bist du schon rausgelaufen, bevor die innere 
überhaupt angefangen hat. d.H. mit "return" kommst du nicht weiter.

Deine query_database function muss entweder asynchron werden, dann kann 
sie vor ihrem return auf die datenbank-query warten, oder muss eine 
callback-funktion als parameter bekommen, die erst aus der inneren 
Funktion heraus aufgerufen wird.

[🐧 DPA 🐧 (Gast)]

Dein Problem ist nicht, dass eine Funktion in einer anderen Funktion 
ist, sondern dass die zweite Funktion asynchron (also später) aufgerufen 
wird.
Die erste Funktion ist zu dem Zeitpunkt, wo die andere aufgerufen wird, 
schon längst wieder beendet. Ein äquivalentes Szenario zum 
veranschaulichen hier:
https://jsfiddle.net/5c7ue1vg/2/

function x(){
  console.log("function x called");
  console.log("Asynchronousely calling y");
  setTimeout(function y(){
    console.log("function y called");
  },0);
  console.log("returning from x");
}
console.log("Calling x");
x();

Bei einer Funktion, die längst zurückgekehrt/durchgelaufen/beendet ist, 
kann man natürlich nichts mehr zurück geben. Aber die 2te Funktion, kann 
eine Funktion aufrufen, die der ersten übergeben wurde. Eine solche 
Funktion nennt man deshalb callback funktion (Rückruffunktion).

function x(callback){
  console.log("function x called");
  console.log("Asynchronousely calling y");
  setTimeout(function y(){
    console.log("function y called");
    console.log("Calling callback function");
    callback(null, "something something");
  },0);
  console.log("returning from x");
}
console.log("Calling x");
x(function z(err, result){
  console.log("Function z here, I got called! I got:", result);
});

Das pattern, bei Callbacks fehler, dann resultat als Argument 
mitzugeben, und den Letzten Parameter ein Callback zu machen, ist nur 
eine Konvention, die sich früher mal durchgesetzt hat. Es hat den 
Vorteil, dass man nicht ständig bei jeder Funktion nachsehen muss, wie 
man den callback übergeben muss, wie man Fehler erkennt, etc. Es ist 
aber nicht zwingend.

Das Problem daran ist halt, dass man die Funktionen auseinandernehmen 
und / oder verschachteln muss, Dinge in callbacks verschieben halt...

Eine erste Verbesserung gab es dann mit Promises.

function x(){
  console.log("function x called");
  let result = new Promise(function q(resolve, reject){
    console.log("Asynchronousely calling y");
    setTimeout(function y(){
      console.log("function y called");
      console.log("Calling callback function");
      resolve("something something");
    },0);
  });
  console.log("returning from x");
  return result;
}
console.log("Calling x");
let result = x();
console.log("Lets let it call a callback once we actually have a result (the promise is fulfilled)");
result.then(function z(result){
  console.log("Function z here, I got called! I got:", result);
});
console.log("Keep in mind, here it wasn't called yet!");

Ein Promise (=Versprechen) Objekt verlagert, woher das Callback kommt. 
Man muss es der Funktion nicht mehr direkt mit geben. Statdessen ist das 
Promise Objekt stellvertretend für ein zukünftiges Resultat, oder einen 
zukünftigen Fehlschlag da. Da das Promise Objekt in der ersten Funktion 
erstellt wurde, kann es von dieser zurückgegeben werden. Und mit .then 
und einer callback funktion kann man dann auf ein Ergebnis, oder einen 
fehler warten. Wobei es für letzteres noch die .catch Methode gibt.

Jede Funktion die die callback Konvention nutzt kann man so in ein 
Equivalent mit promises überführen. Ein Vorteil der Promises ist noch, 
dass beim callback der .then Methode, diese ein Resultat und sogar 
wieder eine Promise zurückliefern kann, und die .then Methode selbst 
auch eine Promise zurück liefert, die dann stellvertretend für dieses 
neue Resultat steht. Damit kann man aus einer Verschachtelung eine Kette 
machen.

Also z.B. aus dem hier: (callback style)

function c_hallo(callback){
  callback(null, "Hallo")
}

function c_martin(str, callback){
  callback(null, str + " Martin");
}

function c_uppercase(str, callback){
  callback(null, str.toUpperCase());
}

c_hallo(function(err, result){
  c_martin(result, function(err, result){
    c_uppercase(result, function(err, result){
      console.log(result);
    })
  });
});

Kann man das hier machen: (promise style)

function p_hallo(callback){
  return new Promise(function(resolve){
    resolve("Hallo");
  });
}

function p_martin(res){
  return new Promise(function(resolve){
    resolve(res + " Martin");
  });
}

function p_uppercase(res){
  return new Promise(function(resolve){
    resolve(res.toUpperCase());
  });
}

p_hallo()
  .then(p_martin)
  .then(p_uppercase)
  .then(console.log);

Btw. in diesem speziellen fall könnte man das auch kürzer schreiben:

Promise.resolve("Hallo")
  .then(res => res + " Martin")
  .then(res => res.toUpperCase())
  .then(console.log);

Weil eigentlich alle diese 2 Konventionen so konsequent durchziehen, 
gibt es in node convinience Funktionen, um bestehende Funktionen in die 
ander Variante zu überführen, nähmlich die Funktionen util.promisify und 
util.callbackify. util.promisify(c_hallo) liefert eine Funktion zurück, 
die equivalent zu p_hallo. Und util.callbackify(p_hallo) liefert eine 
Funktion zurück, die equivalent zu c_hallo ist. Wenn man also eine 
Variante hat, aber die andere braucht, nimmt man einfach diese 2 
Hilfsfunktionen.

Mit ES7 und async await wurde das dann weiter vereinfacht. async await 
sind Syntax Konstrukte  um une die ganzen .then und separate Callbacks 
auszukommen. Damit sieht eine asynchrone Funktion wieder fast genau so 
aus, wie eine Synchrone.

Die p_uppercase Funktion kann mit async wie folgt geschrieben werden:

async function p_uppercase(res){
  return res.toUpperCase();
}

Das coole daran sieht man aber, wenn man die .then chain von oben 
schreibt:

async function x(){
  var resultat;
  resultat = await p_hallo();
  resultat = await p_martin(resultat);
  resultat = await p_uppercase(resultat);
  console.log(resultat);
}
x();

Oder auch:

async function x(){
  console.log( await p_uppercase( await p_martin( await p_hallo() ) ) );
}

Mit await "wartet" man quasi also auf das Resultat einer Promise, und 
wenn es ankommt, geht's weiter. Es gibt nur 2 wichtige Unterschiede die 
man bei Async funktionen beachten muss:
 1) async funktionen können überal dort, wo await steht, "unterbrochen" 
werden. Das heisst, andere async & callback functionen könnten an den 
Stellen wärend dem Warten auf das Ergebnis ausgeführt werden.
 2) Man darf nicht vergessen, das await überall hinzuschreiben, wo man 
das Resultat einer Promise braucht.

[Joachim S. (oyo)]

So sollte Dein Code-Stück funktionieren:

module.exports = {
  query_database : (query, SQL_ID) => new Promise((resolve, reject) => {
    // "select distinct * from main"
    connection.query(query, (err, recordsArray, fields) => {
      if (err) {
        //console.log("Error occured while fetching the data - module database !!");
        reject(err);
      } else {
        const objJson = JSON.parse(JSON.stringify(recordsArray)); // Important Make a Sting fom an Object we get
        const myfunction = require("../myfunctions/myfunctions");
        const obj = myfunction.fetch_Json(objJson, SQL_ID); // Here I get a specific Dataset
        //console.log(obj); // Here I het my Json Object
        resolve(obj);
      }
    });
  }
}

Benutzen kannst Du es dann z.B. so:

require("<name Deines Moduls>").query_database(<query>, <SQL_ID>)
.then((obj) => {
  // Hier kommt Dein Code hin, der das obj-Objekt verwendet
})

oder so

async () => {
  const obj = await require("<name Deines Moduls>").query_database(<query>, <SQL_ID>);
  // Hier kommt Dein Code hin, der das obj-Objekt verwendet
}

Aber vermutlich solltest Du Dich wirklich erst einmal kurz einlesen, wie 
moderne asynchrone Programmierung in Javascript mit Promises bzw 
async/await funktioniert, sonst wirst Du vermutlich schnell auf das 
nächste Problem stossen.
EDIT: Ok, DPA hat netterweise schon mal eine Kurzzusammenfassung für 
Dich geschrieben.

[Martin M. (ats3788)]

Ich danke euch das muss ich erst mal durcharbeiten.
Komme aus der Pascal Welt und dies asynchrone Verarbeitung ist sehr
merkwürdig.
Danke Joachim ja das sollte ich, nur ich wollte ein wenig mit Java 
Script herumspielen, großes habe ich nicht vor.