Jahresrückblick 2025 – unser neuer Blogbeitrag ist online! ✨

[Ben1983]

Hallo, da ich nicht zuviel globale funktionen erstellen wollte, habe ich mir gerade gedacht ich nutze die messageTo Methode, um mir einen bestimmten String zurückgeben zu lassen.
Leider funktioniert dies ja nur über einen callback und ich kann beim empfänger der onMessage keinen Rückgabewert eintragen.
Nun ist das Problem das:

Ich befinde mich innerhalb einer Abarbeitung und das script läuft schon weiter, bevor die callback funktion kommt.
Die wäre zu umgehen mit einem Rückgabewert, oder hat jemand eine bessere Idee?

Ich benötige also so etwas:

...
let abc = getStringxy();
log(abc);
...

bevor der Callback der messageTo greift wurde log(abc) schon ausgeführt.

[paul53]

@ben1983 sagte: nicht zuviel globale funktionen

Stattdessen messageTo() ?

[Ben1983]

@paul53 Ja wie gesagt war aufgrund der globalen funktion (um diese nicht global zu benötigen) folgendes zu machsen:

let abc;
messageTo("Testmessage",data,(dp)=>{
    // Hier der callback mit
    abc = dp;
});
log(abc);

aber das script ist schon durchgelaufen, wenn der callback kommt.
Hier nur ein einfaches Beispiel. Man kann sich natürlich mehr vorstellen, was hinter der funktion passiert.

[paul53]

@ben1983 sagte: script ist schon durchgelaufen, wenn der callback kommt.

Das ist bei allen asynchronen Funktionen (das Ergebnis wird an eine Callback-Funktion übergeben) so. Die Auswertung des Ergebnisses muss also in einer Funktion erfolgen.
EDIT: Wenn die Auswerte-Funktion nicht anonym sein soll:

function auswertung(abc) {
    log(abc);
    // weitere Auswertungen von abc
}

messageTo("Testmessage", data, auswertung);

[Ben1983]

@paul53 Ja, aber das ändert ja nichts daran, dass die funktion "zu Spät" aufgerufen wird.

function auswertung(abc) {
    // hier wird abc verarbeitet
}
 
messageTo("Testmessage", data, auswertung);
// Hier wird auf abc reagiert, aber es hat ja noch nicht den richtigen Wert,
// da der Callback ja noch nicht aufgerufen wurde, oder?

Schön wäre es, wenn das messageTo mit await möglich wäre.
sonst müsste man dahinter ein await wait(500) bringen oder so, aber das ist nicht so die feine Art finde ich.

[paul53]

@ben1983 sagte

// Hier wird auf abc reagiert, aber es hat ja noch nicht den richtigen Wert,                                                                                                                                                                            // da der Callback ja noch nicht aufgerufen wurde, oder?

Dort kann eben nicht auf abc reagiert werden, sondern nur in der Auswerte-Funktion.
Das ist eine Eigenheit der Ereignis orientierten Sprache Javascript.

[OliverIO]

@ben1983 sagte in messageTo mit Rückgabewert?:

warum nicht so?

let abc;
messageTo("Testmessage",data,(dp)=>{
    // Hier der callback mit
    abc = dp;
    log(abc);
});

messageTo ist eine asynchrone Funktion. Mehr dazu mit (allgemeine) Beispielen hier
https://javascript.info/callbacks

Warum willst du die Funktion mit messageTo aufrufen? Evtl bist du da auf dem falschen Weg unterwegs.
Globale funktionen im javascript adapter helfen eigentlich nur, das man den code nicht für jedes neue skript erneut schreiben muss. beim start wird technisch der code allerdings einfach nur vor dein skript kopiert.
https://github.com/ioBroker/ioBroker.javascript/blob/master/docs/en/javascript.md#global-functions
mehrere verschiedene skripte können nicht über die globalen funktionen miteinander kommunizieren. daher jedes skript hat seine eigenen variablen zu jedem globalen skript

daher, wenn du bspw nachschlage tabellen als globale funktion umsetzen willst ist das ok.
dafür musst du aber nicht onMessage und messageTo verwenden, da reicht auch einfach nur folgendes

globalskript

function test() {
    return "test";
}

normales skript

log(test());

wenn du die beiden skripte anlegst und startest (erst global dann das normale), dann gibt das normale skript "test" aus

[Ben1983]

@oliverio Ich weiß, dass die globalen in jedem skript davor gesetzt werden.
Deshalb wollt ich sie ja direkt vermeiden.

Dein Bsp. mit

let abc;
messageTo("Testmessage",data,(dp)=>{
    // Hier der callback mit
    abc = dp;
    log(abc);
});

kann ich leider nicht so machen, weil im haupt skript, welches das messageTo aufruft eben noch weiteres passiert.
(nach dem messagTo Aufruf, was aber erst nach dem Callback passieren sollte / darf.

Ich müsste dann das Skript dahingehen aufbauen, dass der callback diesen Teil dann aufruft,
aber dann müsste ich alles umbauen... glaube dann erzeuge ich lieber eine globale Funktion :-)

[paul53]

@ben1983 sagte: Deshalb wollt ich sie ja direkt vermeiden.

Was stört Dich daran? Wenn die (globale) Funktion im Skript nicht aufgerufen wird, wird sie auch nicht kompiliert. Node.js arbeitet nicht mit Unterprogrammen (Bibliotheken), sondern verwendet Copy & Paste.

[Ben1983]

@paul53 ach so, ich dachte die wir immer davor kopiert.
Wenn die also nicht verwendet wird, dann wird sie auch nicht kopiert. Na dann ist es ja keine Frage. Ok. Danke

Aber es wird immer erst der „Hauptthread“ ausgeführt?

Also:

function getmystring(){
return „2“};
log(„1“);
log(getmystring());
log(„3“);

Liefert als log
1
2
3

Und

onMessage(„Test“,(data,callback){
log(„2“);};);

log(„1“);
messageTo(„Test“,“xyz“);
log(„3“);

Liefert:
1
3
2

Richtig? … zumindest bei mir 😉

[paul53]

@ben1983 sagte: ich dachte die wir immer davor kopiert.

Wird sie auch unmittelbar vor dem Kompilieren, der Compiler verwendet sie aber nur beim Aufruf.

@ben1983 sagte in messageTo mit Rückgabewert?:

es wird immer erst der „Hauptthread“ ausgeführt?

Der Hauptthread ist meist schneller als die asynchrone Funktion. Die asynchrone Funktion wird nur "angestoßen", bevor es im Hauptthread weiter geht.

[Ben1983]

@paul53 OK, also wird nicht wirklich wie in einer funktion in das messagaTo (in dem Beispiel) rein gesrungen und der code ausgeführt, sondern "nur" so zu sagen vermerkt, dass diese Methode aufgerufen werden soll und dann geht es schon im Hauptthread weiter. Richtig?

[paul53]

@ben1983 sagte: vermerkt, dass diese Methode aufgerufen werden soll und dann geht es schon im Hauptthread weiter. Richtig?

So oder so ähnlich.

[Ben1983]

@paul53 Sie wird aber wirklich erst am Ende aufgerufen.
siehe dieses Beispiel:

function logAufruf(i){
    log(i);
}

onMessage("Aufrufschreife",(data,callback)=>{
    for(let i = data; i > 0 ; i--){
        log("Messageaufruf" + i);
    }
});

log("Start");
messageTo("Aufrufschreife",10);
for(let i = 10;i>0;i--){
    log("Außen" + i);
}

Das führt zu folgendem log: Ich habe es mal per screenshot eingefügt, damit man direkt sieht, es werden erst die Aüßeren Befehle ausgeführt und dann die inneren....

Ps. Ich kann auch 10000 logs eintragen, es werden auch dann erst die Äußeren komplett ausgeführt.

[paul53]

@ben1983 sagte: es werden auch dann erst die Äußeren komplett ausgeführt.

Schön, dass Du es mal getestet hast. :+1:

[fastfoot]

die sendTo Funktion arbeitet halt asynchron, d.h. ein Ergebnis wird irgendwann zurückgeliefert, nicht zwingend sofort. Das Hauptprogramm macht dann derweil andere Dinge bis das Ergebnis da ist. In dem Fall gibt man einen callback mit der dann das Ergebnis verarbeitet. Ist wie im richtigen Leben: Du rufst in die Küche bringste mal'n Bier mit, bitte? Jetzt gehts aber weiter mit Fussball in der Glotze, wenn das Bier dann da ist wirds getrunken, in der Glotze nix versäumt. Du könntest auch in den await Modus gehen, umgedreht Richtung Küche auf dein Bier wartend. Schauen kannste jetzt nicht mehr aber auf sonstige Ereignisse trotzdem reagieren(es fällt ein Tor, das hörst du und kannst sofort reagieren, Sch........... verpasst!!!).

So ähnlich verhält es sich mit async/await, während dem await ist zwar der laufende Code blockiert, auf Ereignisse(z.B onMessage anderswo im Skript) kann trotzdem reagiert werden. Um diese Funktionalität zu erhalten kann man Funktionen welche Callbachs verwenden in einen Wrapper mit Promise packen und dann mit await darauf warten.

const messageToAsync = async function (data) {
    return new Promise((resolve, reject) => {
        messageTo("addiere5", data, (erg) => {
            if (erg) resolve(erg);
        })
    })
}

log(await messageToAsync(3))
log(await messageToAsync(6))

Bei eigenen Funktionen kann man sich jetzt überlegen ob man sich das antun will oder lieber nach Alternativen sucht, viele ältere Tools (z.B request() )arbeiten jedoch noch mit Callbacks und da ist so ein Wrapper schon eine coole Sache. Für request() gibt es axios als Alternative, da kann man dann auch await verwenden

[Ben1983]

@fastfoot ok. danke.

[fastfoot]

@ben1983 das hast du aber schon geschnallt dass der cb nur einmal aufgerufen werden kann? Du bekommst auch keine 100 Bier wenn du nur einmal in die Küche rufst. Der cb ist da um ein Ergebnis zurück zu geben, der Aufrufer möchte auch nur ein Ergebnis haben und behandelt das auch nur einmal, ein mehrfacher Aufruf des cb ist Quatsch!!!

[Ben1983]

@fastfoot ja in dem Beispiel schon.
ein normaler einer funtion übergebener callback kann ja auch mehrfaxh aufgerufen werden.
natürlich macht es am meisten sinn das nur einmal zu machen.

[Ben1983]

@fastfoot Aber davon abgesehen sind für dinge die direkt zurück kommen "normale" funktionen doch die richtige Wahl.
wenn es etwas ist was dauern kann, dann asynchrone.... und wenn man warten will, dann eben die variante mit await.

oder?