Javascript-Grundlagen: Detaillierte Erklärung der Operatoren und der Flusskontrolle

  //Alarm(1 + 1);
        console.log(1 + 1); // Geben Sie auf beiden Seiten des Operators Leerzeichen ein //alert(1 - 1); //0
        //alarm(1 * 1); //1
        //alarm(1 / 1); //1

//alarm(4 % 2); //0
 //alarm(5 % 3); //2
//alert(3 % 5); //3 Achtung! ! ! ! ! ! ! ! ! !

  var result = 0.1 + 0.2; // Das Ergebnis ist nicht 0,3, sondern: 0,30000000000000004
  console.log(0.07 * 100); // Das Ergebnis ist nicht 7, sondern: 7.000000000000001

 Varnum = 0,1 + 0,2;
 alert(num == 0.3); //false Bei der Konvertierung in Binärzahlen treten Genauigkeitsfehler auf

 <Skript>
        //1. Möchte einer Variablen 1 hinzufügen: num=num+1, was problematisch ist: var num = 1;
        Zahl = Zahl + 1; // ++Zahl
        Zahl = Zahl + 1;
        //alarm(Zahl); //3
        //2. Stellen Sie den Inkrementoperator ++ vor die Variable var age = 20;
        ++Alter; //ähnlich wie Alter = Alter + 1
        //alarm(Alter); //21
        // 3. Addiere zuerst 1 und gib dann den Wert zurück var p = 10;
        Alarm(++p + 10); //21
    </Skript>

 <Skript>
        varnum = 10;
        Zahl++; // Zahl = Zahl + 1 ++Zahl
        // Alarm(Zahl); //11
        //1. Wenn Pre-Increment und Post-Increment getrennt verwendet werden, ist der Effekt derselbe //2. Post-Increment-Formel: Gib zuerst den ursprünglichen Wert zurück und addiere dann 1
        var Alter = 10;
        //alarm(Alter++ + 10); //20
        //alarm(Alter); //11
        //alarm(Alter + 10); //21
    </Skript>

 <Skript>
        var a = 10;
        ++a; //++a = 11 a=11 ++a ist ein Ausdruck var b = ++a + 2; // a=12 a++ = 12 Präfix: zuerst sich selbst hinzufügen, dann den Wert zurückgeben //alert(b); //14  
        var c = 10;
        c++; //c++ = 11 c = 11
        var d = c++ + 2; //c++ = 11 c = 12 Postposition: zuerst den Originalwert zurückgeben, dann hinzufügen //alert(d); //13
        var e = 10;
        var f = e++ + ++e; // e++ =10 e=11 ++e=12
        console.log(f); //22
        // Der Post-Increment-Ausdruck gibt den ursprünglichen Wert zurück und erhöht dann die Variable um 1
        // Zuerst das Inkrement mit dem Präfix, dann die Operation // Wenn es alleine verwendet wird, sind die laufenden Ergebnisse dieselben // Bei der Entwicklung verwenden die meisten Leute das Inkrement/Dekrement mit dem Postfix, und der Code nimmt eine einzelne Zeile ein, zum Beispiel: num++; oder num--
 </Skript>

<Skript>
        // Alarm (3 >= 5); // falsch
        // Alarm (2 <= 5); // wahr
        //1. Das Gleichheitszeichen in unseren Programmierern ist ==. Der Standardkonvertierungsdatentyp konvertiert Zeichenfolgendaten in numerische Daten. //Nur der Wert muss relativ sein. //alert(3 == 5); //false
        //alarm('rosa Lehrer' == 'Andy Lau'); //falsch 
        //alarm(18 == 18); //wahr
        //alarm(18 == '18'); //wahr
        //alert(18 != 18); //false != ungleich //2. Unter uns Programmierern haben wir die Anforderung, dass die Werte auf beiden Seiten genau gleich sind und die Datentypen genau gleich sein müssen, damit es wahr ist
        //alarm(18 === 18); //wahr
        //alarm(18 === '18'); //falsch 
</Skript> 

 <Skript>
        // 1. Logisches UND && (und) Das Ergebnis ist wahr, wenn beide Seiten wahr sind. Solange eine Seite falsch ist, ist das Ergebnis falsch
        //alarm(3 > 5 && 3 > 2); //falsch
        //alarm(3 < 5 && 3 > 2); //wahr
        // 2. Logisches oder || (oder) Wenn beide Seiten falsch sind, ist das Ergebnis falsch. Solange eine Seite wahr ist, ist das Ergebnis wahr.
        //alarm(3 > 5 || 3 > 2); //wahr
        //alarm(3 > 5 || 3 < 2); //falsch
        //3. Logische Negation! (nicht)
        alarm(!true); //falsch
    </Skript>

   <Skript>
        Variable Nummer = 7;
        var str = "Ich liebe dich, China,";
        alert(Zahl > 5 && Zeichenkettenlänge >= Zahl); //wahr
        alert(num < 5 && str.length >= num); //falsch
        alarm(!(num < 10)); //falsch
        alert(!(num < 10 || str.length == num)); //falsch
    </Skript>

  3. Logische UND-Kurzschlussoperation Wenn Ausdruck 1 wahr ist, wird Ausdruck 2 zurückgegeben. Wenn Ausdruck 1 falsch ist, wird Ausdruck 1 zurückgegeben.
        alert(123 && 456); //456 Außer 0 sind alle Zahlen wahr alert(0 && 456); // 0
        alarm(0 && 1 + 2 && 456 * 56789); // 0
        Alarm('' && 1 + 2 && 456 * 56789); // ''
        Wenn irgendeins leer oder negiert ist, ist es falsch, der Rest ist wahr: 0 '' null undefiniert NaN

 4. Logische oder Kurzschlussoperation Wenn Ausdruck 1 wahr ist, wird Ausdruck 1 zurückgegeben. Wenn Ausdruck 1 falsch ist, wird Ausdruck 2 zurückgegeben.
        alarm(123 || 456); // 123
        Alarm(123 || 456 || 456 + 123); // 123
        Alarm(0 || 456 || 456 + 123); // 456

Eine logische Unterbrechung ist sehr wichtig, sie beeinflusst die Ergebnisse unseres Programms var num = 0;
        //alert(123 || num++); //123 num++ wird nicht ausgeführt //alert(num); // 0

  <Skript>
        varnum = 10;
        // Zahl = Zahl + 1; //Zahl++
        // Zahl = Zahl + 2 //Zahl+=2;
        varnum = 10;
        Zahl += 5;
        // Alarm(Zahl); //15
        varnum = 10;
        Zahl -= 5;
        // Alarm(Zahl); //5
        var Alter = 2;
        Alter *= 3;
        // Alarm(Alter); //6
        var Alter = 6;
        Alter /= 3;
        // Alarm(Alter); //2
        var Alter = 4;
        Alter%= 2;
        // Alarm(Alter); //0
    </Skript>

  <Skript>
        // Unärer Operator: ++num !num Binärer Operator: 2 + 3
        // Übung 1
        console.log(4 >= 6 || 'Avatar' != 'Avatar' && !(12 * 2 == 144) && true) //wahr
        varnum = 10;
        console.log(5 == Zahl / 2 && (2 + 2 * Zahl).toString() === '22'); //wahr
        console.log('------------------');
        // Übung 2
        var a = 3 > 5 und 2 < 7 und 3 == 4;
        console.log(a); //falsch
        var b = 3 <= 4 || 3 > 1 || 3 != 2;
        console.log(b); //wahr
        var c = 2 === "2";
        console.log(c); //false
        var d = !c || b && a;
        console.log(d); //wahr
    </Skript>

        if (bedingter Ausdruck) {
            //Anweisung ausführen}
        2. Ausführungsidee Wenn das Ergebnis des bedingten Ausdrucks in if wahr ist, wird die Ausführungsanweisung in den geschweiften Klammern ausgeführt. Wenn das Ergebnis des bedingten Ausdrucks if falsch ist, wird die Anweisung in den geschweiften Klammern nicht ausgeführt und der Code nach der if-Anweisung wird ausgeführt. 3. Erfahrungscode:
        wenn (3 < 5) {
            Alarm ('Wüstenkamel');
        }

  <Skript>
        // Das Eingabefeld wird angezeigt. Der Benutzer gibt das Alter ein. Das Programm übernimmt diesen Wert und speichert ihn in der Variablen. // Bestimmen Sie das Alter mit der if-Anweisung. Wenn das Alter über 18 liegt, führen Sie die Ausgabeanweisung in den if-Klammern aus. var age = prompt ('Bitte geben Sie Ihr Alter ein');
        wenn (Alter >= 18) {
            alert('Sie können das Internetcafé betreten')
        }
    </Skript>

<Skript>
        // 1. Syntaxaufbau if else // if (bedingter Ausdruck) {
        // // Anweisung 1 ausführen
        // } anders {
        // // Anweisung 2 ausführen 
        // }
        // 2. Ausführungsidee Wenn das Ergebnis des Ausdrucks wahr ist, führen Sie Anweisung 1 aus, andernfalls führen Sie Anweisung 2 aus
        // 3. Codeüberprüfung var age = prompt('Bitte geben Sie Ihr Alter ein:');
        wenn (Alter >= 18) {
            alert('Ich möchte dich ins Internetcafé bringen, um Kopfhörer zu stehlen');
        } anders {
            alert('Geh weg und mach deine Hausaufgaben');
        }
        // 5. Es kann nur eine der Anweisungen 1 in if und 2 in else ausgeführt werden.
        // 6. Auf else folgen direkt geschweifte Klammern</script>

  // Algorithmus: Ein Schaltjahr ist durch 4 teilbar, nicht durch 100 (z. B. ist 2004 ein Schaltjahr, 1901 ist kein Schaltjahr) oder ein Schaltjahr ist durch 400 teilbar // Ein Eingabefeld wird eingeblendet, der Benutzer kann das Jahr eingeben, den Wert übernehmen und in einer Variablen speichern // Bestimmen Sie mit einer if-Anweisung, ob es ein Schaltjahr ist. Wenn es ein Schaltjahr ist, führen Sie die Ausgabeanweisung in den if-Klammern aus, andernfalls führen Sie die Ausgabeanweisung in den else-Klammern aus // Achten Sie unbedingt auf die Schreibweise von && und oder || und beachten Sie auch, dass die Methode zur Beurteilung, ob es teilbar ist, darin besteht, den Rest als 0 zu nehmen
         var year = prompt("Bitte geben Sie das zu testende Jahr ein:")
        wenn (Jahr % 4 == 0 && Jahr % 100 != 0 || Jahr % 400 == 0) {
            alert(year + 'ist ein Schaltjahr')
        } anders {
            alert(year + 'ist ein normales Jahr')
        }

<Skript>
        // 1. Eine Multi-Branch-Anweisung ist ein Prozess, bei dem mehrere Bedingungen verwendet werden, um unterschiedliche Anweisungen zur Ausführung auszuwählen und unterschiedliche Ergebnisse zu erhalten. // 2. Es ist eine Multi-Branch-Anweisung // 3. Syntaxspezifikation if else if-Anweisung if (bedingter Ausdruck 1) {
            //Anweisung 1;
        } sonst wenn (bedingter Ausdruck 2) {
            //Anweisung 2;
        } sonst wenn (bedingter Ausdruck 3) {
            //Anweisung 3;
        } anders {
            //Letzte Anweisung;
        }
        // 4. Ausführungsideen // Wenn bedingter Ausdruck 1 erfüllt ist, führe Anweisung 1 aus. Beende nach der Ausführung die gesamte if-Verzweigungsanweisung // Wenn bedingter Ausdruck 1 nicht erfüllt ist, bestimme, ob bedingter Ausdruck 2 erfüllt ist, und führe Anweisung 2 aus. Und so weiter // Wenn alle oben genannten bedingten Ausdrücke nicht erfüllt sind, führe die Anweisungen in else aus // 5. Zu beachtende Punkte // (1) Mehrere Verzweigungsanweisungen oder Multiple Choice 1. Am Ende kann nur eine Anweisung ausgeführt werden // (2) Theoretisch kann else if eine beliebige Anzahl von Bedingungen enthalten // (3) In der Mitte von else if steht ein Leerzeichen</script>

    <Skript>
        // Der Pseudocode folgt der Idee, von groß nach klein zu beurteilen // Ein Eingabefeld für die Eingabeaufforderung anzeigen, in das der Benutzer die Punktzahl (Score) eingeben und diesen Wert in einer Variablen speichern kann // Zum Beurteilen und Ausgeben verschiedener Werte mehrverzweigte if-else-if-Anweisungen verwenden var score = prompt('Bitte geben Sie eine Punktzahl ein:');
        wenn (Punktzahl >= 90) {
            Alarm('A');
        } sonst wenn (Score >= 80) { //Es ist nicht nötig, 90>Score>=80 zu schreiben, um Folgendes auszuführen, es muss kleiner als 90 sein alert('B');
        } sonst wenn (Punktzahl >= 70) {
            Alarm('C');
        } sonst wenn (Punktzahl >= 60) {
            Alarm('D');
        } anders {
            alert('E'); //Anführungszeichen sind erforderlich, sonst wird es als Variable betrachtet und muss deklariert werden.}
    </Skript>

<Skript>
        // 1. Der aus ternären Operatoren zusammengesetzte Ausdruck heißt ternärer Ausdruck // 2. Unärer Operator: ++num Binärer Operator: 3 + 5 Ternärer Operator: ? :
        // 3. Syntaxstruktur // Bedingter Ausdruck? Ausdruck 1: Ausdruck 2
        // 4. Ideen zur Ausführung // Wenn der bedingte Ausdruck wahr ist, geben Sie den Wert von Ausdruck 1 zurück. Wenn der bedingte Ausdruck falsch ist, geben Sie den Wert von Ausdruck 2 zurück. // 5. Code-Erfahrung var num = 10;
        var result = num > 8 ? 'Ja' : 'Nein' // Wir wissen, dass der Ausdruck einen Rückgabewert hat, weisen ihn result zu 
        console.log(Ergebnis); //Ja//Entspricht:
        varnum = 10;
        wenn (Zahl > 5) {
            Alarm('Ja');
        } anders {
            Warnung ('Nein');
        }
        // Der ternäre Ausdruck ist eine vereinfachte Version von if else
    </Skript>

   <Skript>
        // Der Benutzer gibt eine Zahl zwischen 0 und 59 ein. // Wenn die Zahl kleiner als 10 ist, fügen Sie vor der Zahl eine 0 hinzu (fügen Sie 0 zur Verkettung hinzu), andernfalls wird keine Operation ausgeführt. // Verwenden Sie eine Variable, um diesen Rückgabewert zu erhalten, und geben Sie var num = prompt aus (,Bitte geben Sie eine Zahl zwischen 0 und 59 ein?‘).
            //Ternärer Ausdruck: Ausdruck? Ausdruck 1: Ausdruck 2;
        var result = num < 10 ? '0' + num : num; //Zeichentyp 0 Weisen Sie den Rückgabewert einer Variablen zu alert(result);
    </Skript>

    <Skript>
        //1. Die switch-Anweisung ist ebenfalls eine Multi-Branch-Anweisung und kann auch Mehrfachauswahlen implementieren 1
        // 2. Syntaxstruktur switch Konvertierung, switch case kleines Beispiel oder Option Bedeutung break exit /* switch (Ausdruck) {
                Fallwert1: Anweisung 1 ausführen; abbrechen;
                Fallwert2: Anweisung 2 ausführen; abbrechen;
                Fallwert3: Anweisung 3 ausführen; abbrechen;
                Standard: Führe die letzte Anweisung aus.
            } */
        // 3. Ausführungsidee: Verwenden Sie den Wert unseres Ausdrucks, um den Optionswert nach dem Fall abzugleichen. Wenn er übereinstimmt, führen Sie die Anweisung im Fall aus. Wenn er nicht übereinstimmt, führen Sie die Anweisung standardmäßig aus. switch (2) {
            Fall 1: Warnung (,Dies ist 1'); Unterbrechung;
            Fall 2: Warnung ('Dies ist 2'); Unterbrechung; //Dies ist 2
            Fall 3: Warnung (,Dies ist 3'); Unterbrechung;
            Standard: alert('Keine passenden Ergebnisse');
        }
    </Skript>

        Variable Nummer = 1;
        Schalter(Nummer){
            Fall 1: console.log(1);break; //1
            Fall 2: console.log(2);unterbrechen;
            Fall 3: console.log(3);unterbrechen;
        }
        // 1. Wenn wir Ausdrücke entwickeln, schreiben wir sie oft als Variablen // 2. Wenn der Wert von num mit dem Wert in case übereinstimmt, sind sie identisch. Der Wert und der Datentyp müssen konsistent sein. num === 1

  Variable Nummer = 1;
        Schalter(Nummer){
            Fall 1: console.log(1);//1
            Fall 2: console.log(2);//2
            Fall 3: console.log(3);//3
        }

<Skript>
        // Öffnen Sie ein Eingabefeld, lassen Sie den Benutzer den Namen der Frucht eingeben und speichern Sie den Wert in einer Variablen.
        // Verwenden Sie diese Variable als Ausdruck innerhalb der Schalterklammern.
        // Schreiben Sie mehrere verschiedene Fruchtnamen in den Wert nach Groß-/Kleinschreibung. Beachten Sie, dass Sie Anführungszeichen hinzufügen müssen, da es sich um eine exakte Übereinstimmung handeln muss.
        // Einfach unterschiedliche Preise anzeigen. Beachten Sie auch, dass nach jedem Fall ein „Break“ hinzugefügt wird, um die Switch-Anweisung zu beenden.
        // Standardmäßig auf „Keine solche Frucht“ setzen.
        var fruit = prompt('Bitte geben Sie den Namen der Frucht ein')
        Schalter (Obst) {
            Fall 'Apfel':
                alert('Der Preis für Äpfel beträgt 3,5/Catties');
                brechen;
            Fall 'Durian':
                alert('Der Preis für Durian beträgt 35/Catties');
                brechen;
            Standard:
                alert('Es gibt keine solche Frucht');
        }
    </Skript>