Erläuterung der JavaScript-Funktionssyntax

// 1. Funktionsdefinition
Funktion printHello_1$_(name_0) 
{
    //Ausführung
    console.log("Hallo Welt!" + name_0);
}
console.log(Typ von printHello_1$_);
// 2. Funktionsaufruf
printHello_1$_(); 
// 3. Funktionsbenennung
// 4. Funktionsparameter
// 5. Funktionsrückgabe

// 6. Die Funktion kann auch keinen Namen haben und direkt so erstellt werden.
lass ihn = function(){
    console.log("ihn");
}
him() // Dies zeigt, dass der Name tatsächlich ein Variablenname ist.
// 8. Der Funktionsname selbst unterstützt keine Werteübertragung, Variablen jedoch schon.
// him = printHello_1(); // Fehler (ähnlich der Tatsache, dass nach der Definition eines Arrays keine Werte zugewiesen werden können?)
lass add = ihn;
hinzufügen();
// 7. Dieser Variable können noch andere Inhalte zugewiesen werden.
er = 6;
console.log(him) // Gib die Zahl 6 aus

wenn (falsch)
{
    const add = (a, b) => a + b; // Ähnlich wie das direkte Erstellen einer Funktion und deren Aufruf durch Zuweisung zu einer Variablen.
    console.log(add(1,3)); //Es wird kein Rückgabewert geschrieben und der berechnete Wert wird implizit zurückgegeben}
wenn (falsch)
{
    sei add = (a, b) => a + b;
    console.log(add(1,3)); // drucke 4
    const add_0 = add; // Sie können es durch eine normale Variablenzuweisung ersetzen add = 5; // Es ist ersichtlich, dass es sich im Wesentlichen immer noch um eine Variable handelt. Wenn die Definition einen Variablentyp verwendet, können Sie ihn ändern console.log(add); // Drucken Sie 5
    console.log(add_0(2, 4)); // gibt 6 aus
}
wenn (falsch)
{
    console.log(add_0(10, 4)); // const-Variablentypen können nicht den Gültigkeitsbereich überschreiten}

wenn (falsch)
{
    const add = (a, b) => 
    {
        gib a + b zurück;
    }
    console.log(add(1,3)); // Es gibt einen Rückgabewert, was bedeutet, dass die Verwendung von geschweiften Klammern zwar einen Zeilenumbruch anzeigen kann, aber keine implizite Rückgabe erfolgt. Eine einzelne Zeile verfügt immer über eine implizite Rückgabe.
}

// Beispiel 1
wenn (falsch)
{
    const book = neues Objekt({title : "1984", author : "George Orwell"}) // JSON-Objekt erstellen console.log("\n ---------")
    console.log(typeof book) // Überprüfe den Typ, es ist tatsächlich ein Objekt console.log(book) // Kann normal drucken}
// Beispiel 2 (Detaillierte Erklärung im nächsten Abschnitt, Wissenspunkte zu Objekten)
wenn (falsch)
{
    const book = ({title : "1984", author : "George Orwell"}) // Auch ohne das Hinzufügen des Schlüsselworts Object kann derselbe Effekt erzielt werden.
    konsole.log("\n ---------")
    console.log(Buchtyp)
    console.log(Buch)
}
// Beispiel 3
wenn (falsch)
{
    const Buch = [
        {Titel: "1984", Autor: "George Orwella"},
        {Titel: "1985", Autor: "George Orwellb"},
        {Titel: "1986", Autor: "George Orwellc"},
        {Titel: "1987", Autor: "George Orwell"}
    ]
    konsole.log("\n ---------")
    console.log(Buchtyp) // Der Drucktyp ist immer noch ein Objekt, aber eigentlich ist es ein Array console.log(Buch)
}

wenn (falsch)
{
    const book = ({title : "1984", author : "George Orwell"}) // Auch ohne das Schlüsselwort Object hinzuzufügen, kann derselbe Effekt erzielt werden.
    konsole.log("\n ---------")
    let bookJSON = JSON.stringify(book); // Objekt im Originalformat behalten und in einen String umwandeln, wobei der Schlüsselname zu einem String wird (d. h., es werden doppelte Anführungszeichen hinzugefügt)? Praktisch zum Speichern im Text?
    console.log(typeof bookJSON) // Wenn ich es mir recht überlege, ist JSON nicht auch die Parameterdatei, die ich verwendet habe, als ich zuvor das ROS-Projekt geschrieben habe? Die Textdateien von Baidu Feijiang liegen ebenfalls in diesem Format vor.
    console.log(buchJSON)
}
/* Die Ausgabe sieht wie folgt aus:
 ---------
Schnur
{"Titel":"1984","Autor":"George Orwell"}
*/
// Sie können feststellen, dass der Schlüsselwert immer noch die ursprüngliche Zeichenfolge ist, der Schlüsselname jedoch in eine Zeichenfolge geändert wurde

wenn (falsch)
{
    const Buch = ([1,23,3,"156"]) 
    konsole.log("\n ---------")
    console.log(typeof book) // Der Typ ist immer noch ein Objekt
    let bookJSON = JSON.stringify(book); // Kann weiterhin ohne Fehler aufgerufen werden.
    console.log(typeof bookJSON) // Das Ergebnis ist eine Zeichenfolge, die genau mit dem ursprünglichen Ergebnis übereinstimmt.
    console.log(buchJSON)
}
/* Die Ausgabe sieht wie folgt aus:
 ---------
Objekt
Schnur
[1,23,3,"156"]
*/
// Es kann festgestellt werden, dass die Funktion anscheinend nicht funktioniert. Es funktioniert nicht und es wird kein Fehler gemeldet, wenn das Format nicht den JSON-Anforderungen entspricht.

wenn (falsch)
{
    lass data_0 = "[1,2,3]";
    let data = "{\"title\" : \"1984\", \"author\" : \"George Orwell\"}"; // Beachten Sie, dass im JSON-String-Format sowohl Schlüssel als auch Werte in doppelte Anführungszeichen eingeschlossen werden müssen, um ein stringähnliches Format zu erstellen. Wenn irgendetwas nicht stimmt, schlägt die Konvertierung fehl.
    let parsed = JSON.parse(data); // Umgekehrte Operation, konvertiere den String zurück in den Objekttyp. Analysiert, ob es dem Format entspricht.
    console.log("\n -----")
    console.log(analysiert); // 
    console.log(analysierter Typ) 
    console.log(Datentyp) 
}
/* Die Ausgabe sieht wie folgt aus:
 -----
{ Titel: '1984', Autor: 'George Orwell' }
Objekt
Schnur
*/
// Beachten Sie, dass der Schrägstrich in der Zeichenfolge problematischer ist

wenn (falsch)
{
    lass data_0 = "[1,2,3]";
    let data = "{\"title\" : \"1984\", \"author\" : \"George Orwell\"}"; // Beachten Sie, dass im JSON-String-Format sowohl Schlüssel als auch Werte in doppelte Anführungszeichen eingeschlossen werden müssen, um ein stringähnliches Format zu erstellen. Wenn irgendetwas nicht stimmt, schlägt die Konvertierung fehl.
    let parsed = JSON.parse(data); // Umgekehrte Operation, konvertiere den String zurück in den Objekttyp. Analysiert, ob es dem Format entspricht.
    console.log("\n -----")
    console.log(analysiert); // 
    console.log(analysierter Typ) 
    console.log(Datentyp) 
}
/* Die Ausgabe sieht wie folgt aus:
 -----
{ Titel: '1984', Autor: 'George Orwell' }
Objekt
Schnur
*/
// Beachten Sie, dass der Schrägstrich in der Zeichenfolge problematischer ist

// 2. Eine andere Möglichkeit, ein Objekt zu erstellen, mit einem Konstruktor if (false)
{
    const Buch = neues Objekt();
    console.log(book); // Die anfängliche Erstellung ist leer console.log(typeof book); // Der Typ ist ein Objekt
    Buchtitel = "1984";
    Buch.Autor = "George Orwell";
    book.isAvailable = false; // Attribut hinzufügen book.checkIn = function(){
        this.isAvailable = true; // Methode hinzufügen };
    buch.checkOut = function(){
        dies.istVerfügbar = falsch; 
    };
     console.log(Buch); // Normal drucken console.log(Typ des Buches);
    // 3. Methoden für den Zugriff auf Elemente innerhalb eines Objekts:
    console.log(book.title); // Zugriff ähnlich einer Struktur console.log(book["title"]); // Zugriff ähnlich einem Wörterbuch, das Ausgabeergebnis ist dasselbe. Beachten Sie, dass bei diesem Zugriff der Schlüsselname in doppelte Anführungszeichen gesetzt und als Zeichenfolge behandelt werden muss console.log(book.checkIn); // Wenn es sich um eine Zugriffsfunktion handelt und keine Klammern hinzugefügt werden, wird ein Objekt zurückgegeben. Ähnliche Zeichen drucken: [Funktion (anonym)]
    console.log(book.checkIn()); // Wenn Sie Klammern hinzufügen, entspricht dies dem Aufruf der Ausführung. (Der Rückgabewert ist leer, da die Funktion keinen Rückgabewert enthält.)
    console.log(book["checkIn"]); // Sie können auch in Wörterbuchform darauf zugreifen, mit demselben Ergebnis console.log(book["checkIn"]()); // Diese Klammer steht außerhalb der eckigen Klammern.
}

wenn (falsch)
{
    const bookObj = { // Erstelle ein Objekt checkIn : function(){ // Füge ein Attribut hinzu return this; // Dieses Attribut ist eine Methode und hat einen Rückgabewert, der das Objekt selbst zurückgibt}
    }
    function anotherCheckIn(){ // Eine Funktion erstellen return this; // Eine Funktion selbst zurückgeben}
    console.log(bookObj.checkIn() == bookObj); // Der Rückgabewert ist das Objekt selbst, richtig console.log(bookObj.checkIn() == globalThis); // Der Rückgabewert ist eine Funktion, falsch console.log(anotherCheckIn() == globalThis); // Der Rückgabewert ist eine Funktion, richtig }

// Das Promise-Objekt wird verwendet, um den endgültigen Abschluss (oder Fehler) einer asynchronen Operation und ihren Ergebniswert darzustellen.
wenn (wahr)
{
    function promiseTimeout(ms){ // Eine Funktion erstellen return new Promise((resolve, reject) => { // Ein Promise-Objekt zurückgeben, der Eingabeparameter ist eine anonyme Funktion, wobei die anonyme Funktion 2 Parameter hat, einer ist der Inhalt, der bei Erfolg ausgeführt werden soll, und der andere ist der Inhalt, der bei einem Fehler ausgeführt werden soll setTimeout(resolve, ms); // interne js-Funktion, den zweiten Parameter um ms verzögern, bevor der Inhalt des ersten Parameters ausgeführt wird
        });
    }
    promiseTimeout(2000) //Rufen Sie die Funktion auf und übergeben Sie den Parameter 2000ms;
        .then(() => { // Integrierte Methode des zurückgegebenen Promise-Objekts; wird bei Erfolg aufgerufen. Diese integrierte Methode hat auch einen Parameter, nämlich eine anonyme Funktion console.log('Done!!'); // Diese anonyme Funktion hat keine Parameter und ihre interne Funktion druckt nur return promiseTimeout(1000); // Rufe die Funktion erneut auf und gib eine andere Variable zurück }).then(() => { // Da das Obige eine andere Variable zurückgibt, kann es in einer Kette aufgerufen werden.
            console.log('Auch erledigt!!'); // 1000 ms verzögern und dann nach erfolgreichem Vorgang „return“ aufrufen Promise.resolve(42); // Ein anderes Objekt zurückgeben, unendlich viele Matrjoschkas }).then((result_0) => { // Parameter übergeben, der Name dieses Parameters ist beliebig, ich kann den Effekt auch nach der Änderung noch erzielen. Die IDE markiert ihn automatisch rot, daher sollten Sie wissen, dass es sich um eine Variable und nicht um ein grammatikalisches Schlüsselwort handelt console.log(result_0); // Parameter drucken })
        .catch(() => { // Wie oben, ruft aber console.log('Error!') auf, wenn es fehlschlägt;
        })
    // Da die Methoden Promise.prototype.then und Promise.prototype.catch Promises zurückgeben, können sie verkettet werden.
}
/*
Die laufenden Ergebnisse sind:
Warten Sie einen Moment und drucken Sie eine Zeile:
Erledigt!
Nach einer kurzen Wartezeit werden zwei Zeilen gleichzeitig gedruckt:
Auch erledigt!
42
*/

// Async:Warten
Funktion promiseTimeout(ms){
    returniere neues Promise((lösen, ablehnen) => {
        setTimeout(Auflösung, ms);
    });
}
asynchrone Funktion longRunningOperation(){
    Rückgabe 42;
}
asynchrone Funktion run() {
    console.log('Start!');
    await promiseTimeout(2000); // Fügen Sie das Schlüsselwort „await“ hinzu, das Ergebnis ähnelt dem synchronen Vorgang. Ursprünglich führte die Verwendung von Promise zuerst zum Drucken und dann zu einer Verzögerung. Wenn A/A hinzugefügt wird, erfolgt zuerst eine Verzögerung und dann der Druck in der richtigen Reihenfolge.
    const Antwort = warte auf longRunningOperation();
    console.log(response); // Logischerweise sollte es 42 zurückgeben und direkt drucken. Tatsächlich wird, wenn das Schlüsselwort await nicht hinzugefügt wird, sofort ein Promise-Objekt statt 42 zurückgegeben.
    console.log('Stopp!!');
}
laufen();
/*
Die laufenden Ergebnisse sind:
Drucken Sie zuerst eine Zeile:
Start!
Nach einer kurzen Wartezeit werden zwei Zeilen gleichzeitig gedruckt:
42
Stoppen!
*/