Wann async/await?

[skorpil]

ich habe ChatGPT gebeten, ein Script von mir zu prüfen. ChatGPT schlägt vor, mit async/await zu arbeiten:

// ###########################################
//      Abwesenheit Klima Schaltungen
//          Deklarationen
// ###########################################

var IDanwesend = 'hm-rega.0.39533' /*Anwesend*/;
var IDklimaBueroManuell = 'hm-rega.0.3070' /*Klima Buero manuell*/;
var IDklimaSchlafManuell = 'hm-rega.0.3116' /*Klima Schlaf manuell*/;

// ###########################################
//            Programm
//    Schaltung bei Anwesend/ Abwesend
// ###########################################

on({id: IDanwesend, change: 'ne'}, async function (data) {
    // Nur bei Abwesenheit fortfahren
    if (!data.state.val) {
        // Zustände der manuellen Klimasteuerung abfragen
        const klimaBueroManuellState = await getStateAsync(IDklimaBueroManuell);
        const klimaSchlafManuellState = await getStateAsync(IDklimaSchlafManuell);

        // Nur ausschalten, wenn der aktuelle Zustand eingeschaltet ist
        if (klimaBueroManuellState.val) {
            await setStateAsync(IDklimaBueroManuell, false);
        }
        if (klimaSchlafManuellState.val) {
            await setStateAsync(IDklimaSchlafManuell, false);
        }
    }
});

mein "Original" war:

// ###########################################
//      Abwesenheit Klima Schaltungen
//          Deklarationen
// ###########################################

var IDanwesend = 'hm-rega.0.39533' /*Anwesend*/;
var IDklimaBueroManuell = 'hm-rega.0.3070' /*Klima Buero manuell*/;
var IDklimaSchlafManuell = 'hm-rega.0.3116' /*Klima Schlaf manuell*/;

// ###########################################
//            Programm
//    Schaltung bei Anwesend/ Abwesend
// ###########################################

on({id: IDanwesend, change: 'ne'}, function (data) {
    // Nur bei Abwesenheit fortfahren
    if (!data.state.val) {
        // Zustände der manuellen Klimasteuerung abfragen
        const klimaBueroManuellState = getState(IDklimaBueroManuell);
        const klimaSchlafManuellState = getState(IDklimaSchlafManuell);

        // Nur ausschalten, wenn der aktuelle Zustand eingeschaltet ist
        if (klimaBueroManuellState.val) {
            setState(IDklimaBueroManuell, false);
        }
        if (klimaSchlafManuellState.val) {
            setState(IDklimaSchlafManuell, false);
        }
    }
});

Macht es Sinn, mit async/await zu arbeiten? Unter welchen Umständen ist das sinnvoll? Ich verstehe die Details nicht. Bleibt die Variante mit async/await nicht quasi "hängen", bis ich "abwesend" bin, was ja manchmal lange dauern kann? Blockiert sie mir Kapazitäten auf dem Rechner? Oder stelle ich mir das komplett falsch vor?????

Danke für Aufklärung!

[OliverIO]

@skorpil

wahrscheinlich brauchst du das nicht.

setState wird asynchron ausgeführt.
das bedeutet, das die beiden Befehle während der Ausführung auf den Stack gelegt wird, aber nicht sofort ausgeführt wird.
Wenn dann das Ende der Funktion erreicht ist und sonst nix anderes bereits auf dem Stack liegt, dann werden die beiden Funktionen der Reihe nach ausgeführt. Denke daran, das auch innerhalb von setState wiederum asynchrone Ausführung erfolgt und da beliebig viel dazwischenfunken kann.

Wenn du nun darauf angewiesen bist, das das setState definitiv ausgeführt wird, bevor die nächste Programmzeile kommt, dann benötigst du await. Also sowas wie warte bis dieser Befehl ausgeführt wurde bevor du zur nächsten Zeile gehst.
So wie es aussieht, brauchst du es hier nicht.

Das warten betrifft nur dieses Skript, es heißt nicht, das andere Skripte, die parallel laufen ebenfalls warten müssen.

Noch ein Zusatz zur "parallelität" von javascript. javascript ist erstmal eine single Thread Applikation. d.h. genau zu einem Zeitpunkt kann genau nur eine einzige Anweisung innerhalb eines Prozesses ausgeführt werden.

Klar kann man innerhalb von javascript noch weitere Prozesse eröffnen oder mehrere javascript.engines können in separaten prozessen laufen, das gehört aber dann doch zu den fortgeschrittenen Anwendungen.

Im folgenden Link wird sehr erschöpfend über die verschiedenen Arten der synchronen und asynchronen(Promise und async/await) Verarbeitung mit einfachen Beispielen berichtet.

https://nerdleveltech.com/understand-the-asynchronous-javascript-callbacks-promises-and-async-await/

[skorpil]

@oliverio danke

[skorpil]

@oliverio ich habe, spaßeshalber mal ChatGPT gefragt, was die Unterschiede sind. Das hat, der bot geantwortet:

Unterschiede und Vergleich:
Synchron vs. Asynchron:

Ihr Vorschlag (getState und setState) verwendet synchrone Funktionen. Diese blockieren die Ausführung des Programms, bis sie abgeschlossen sind.
Mein ursprünglicher Vorschlag (getStateAsync und setStateAsync mit async/await) verwendet asynchrone Funktionen, die die Ausführung des Programms nicht blockieren.
Lesbarkeit und Wartbarkeit:

Der synchrone Code ist oft einfacher zu lesen und zu verstehen, weil er linear abläuft.
Der asynchrone Code mit async/await bietet eine ähnliche Lesbarkeit wie synchroner Code, ohne die Nachteile des Blockierens.
Leistung und Effizienz:

Die synchronen Funktionen können die Leistung beeinträchtigen, insbesondere wenn sie auf langsame I/O-Operationen warten müssen, da sie den Haupt-Thread blockieren.
Asynchrone Funktionen können effizienter sein, da sie den Haupt-Thread nicht blockieren und andere Operationen parallel ausgeführt werden können.
Anwendungsfall:

Wenn getState und setState sehr schnell sind und keine nennenswerte Verzögerung verursachen, kann der synchrone Ansatz ausreichend sein.
Bei zeitaufwändigeren Operationen sind asynchrone Funktionen vorzuziehen, um die Reaktionsfähigkeit des Systems zu erhalten.

Hmmm. Ich werde mich an das halten, was mir die Menschen vorschlagen und nicht die Maschine. Vielen Dank noch mal.

[OliverIO]

@skorpil

ich muss korrigieren.

setState ist tatsächlich synchron und ist optional mit callback funktion
setStateAsync ist asynchron und funktioniert dann mit await

[paul53]

@skorpil sagte: Wenn getState und setState sehr schnell sind

Das synchrone getState(id) ist schnell und effizient, da es den Zustand aus dem Puffer der Javascript-Instanz holt. Die asynchronen Funktionen getStateAsync(id) und getState(id, callback) holen den Zustand vom js-controller und sind deshalb erheblich ineffizienter.
setState() wird asynchron ausgeführt, was man bei der Programmierung beachten muss (kein getState() unmittelbar danach). Man kann zwar die Callback-Funktion von setState() verwenden, was aber niemand macht, da die Verwendung von Variablen effizienter und besser lesbar ist.

[skorpil]

@paul53 danke, Paul, also: synchron!