Super detaillierte grundlegende JavaScript-Syntaxregeln

01 JavaScript (abgekürzt: js)

js ist in drei Teile gegliedert:

• ECMAScript-Standard ---- grundlegende Syntax von js
• DOM------Dokumentobjektmodell Dokumentobjektmodell
• BOM------Browserobjektmodell

Was ist JavaScript?

• Es handelt sich um eine Skriptsprache (keine Kompilierung erforderlich, direkte Ausführung, gängige Skriptsprachen: T-SQL, cmd).
• Es ist eine interpretierte Sprache
• Es ist eine dynamisch typisierte Sprache
• Es ist eine objektbasierte Sprache

Notiz:

1. Eine kompilierte Sprache ist eine Sprache, die in eine für den Computer erkennbare Binärsprache übersetzt werden muss, bevor sie ausgeführt werden kann.

2. Die Frontend-Grundlage ist HTML (Auszeichnungssprache, Anzeigedaten)

CSS (Seite verschönern)

JavaScript (Benutzer- und Browserinteraktion)

Der ursprüngliche Name von js ist nicht JavaScript, sondern LiveScript

Was ist die Rolle von js?

Lösen Sie das Problem der Interaktion zwischen Benutzern und Browsern

js-Code kann an drei Stellen geschrieben werden:

1. Schreiben Sie in der HTML-Datei den JS-Code in das Skript-Tag

2.js-Code kann in das HTML-Tag geschrieben werden

<Skript> 
//js-Code-Alarm("Lerne fleißig und mache jeden Tag Fortschritte"); //Öffne ein Dialogfeld auf der Seite</script> 
<input Typ="Schaltfläche" Wert="Schaltfläche" onclick="alert('Geklickt');"/>

3. Sie können JS-Code in die JS-Datei schreiben, müssen jedoch src="js path" in das Skript-Tag auf der HTML-Seite einfügen.

02 Betreiber

Operatoren: einige für die Berechnung verwendete Symbole

• Arithmetische Operatoren: + - * / %
• Arithmetische Ausdrücke: Ausdrücke, die durch arithmetische Operatoren verbunden sind
• Unäre Operatoren: Dieser Operator benötigt nur einen Operanden. ++ –
• Binärer Operator: Dieser Operator erfordert zum Ausführen zwei Operanden.
• Ternärer Operator: bedingter Ausdruck? Ausdruck1:Ausdruck2
• Zusammengesetzte Operatoren: += -= *= /= %=
• Zusammengesetzter Operationsausdruck: ein Ausdruck, der durch zusammengesetzte Operatoren verbunden ist

 Variable Nummer = 10; 
 num+=10;----->Das heißt: num=num+10; 
 console.log(Nummer);20

• Zuweisungsoperator: =

Relationale Operatoren:

> < >= <=

==Nicht streng

=== Streng

!= lose Ungleichheit

!== Strikte Ungleichheit

Ausdruck der relationalen Operation:

Durch relationale Operatoren verbundene Ausdrücke

Das Ergebnis eines relationalen Ausdrucks ist vom Booleschen Typ.

Logische Operatoren:

&&—Logisches UND – UND

|| – Logisches ODER – Oder

! – Logisches NICHT – Negation – Negation

Ausdruck für logische Operation:

Durch logische Operatoren verbundene Ausdrücke

• Ausdruck1&&Ausdruck2

Wenn eines falsch ist, ist das gesamte Ergebnis falsch

• Ausdruck1||Ausdruck2

Wenn einer davon wahr ist, ist das gesamte Ergebnis wahr

• !Ausdruck 1

Das Ergebnis von Ausdruck 1 ist wahr und das gesamte Ergebnis ist falsch

Das Ergebnis von Ausdruck 1 ist falsch und das gesamte Ergebnis ist wahr

var num1=10; 
var num2=20; 
Konsole.log(Anzahl1==Anzahl2&&5>6)
Variable Nummer = 20; 
Konsole.log(Zahl>10||5<0)
var flag = falsch; 
konsole.log(!flag )
Variable Nummer = 10; 
var Summe=(Zahl+10)*5; 
console.log(Summe 
var Ergebnis = (4 >= 6 || 'Nein' != 'Nein' && !(12 * 2 == 144) && true);
console.log(Ergebnis);
varnum = 10; 
var result2 =( 5 == Num / 2 und (2 + 2 * Num).toString() === '22');
console.log(Ergebnis2); 
​var num=20; 
var result = num/3; //num Variable Modulo 3 ---> Rest von 10/3 console.log(parseInt(Ergebnis) 
Variable Nummer = 20; 
var Ergebnis = Num%3; //Num-Variable Modulo 3 ---> Rest von 10/3 console.log(Ergebnis)
Variable Nummer = 10; 
var Summe = (Zahl + 10) + 1 
varnum = 20; 
       Zahl %= 5; 
// Zahl=Zahl-5; 
console.log(Zahl)
var str="5"; 
Variable Nummer = 5;
console.log(str===num )
console.log(5>10);//falsch 
console.log(5>=5);//wahr 
console.log(5>3);//wahr 
console.log(5==10);//falsch

03 JS-Variablen

Hinweis zu Variablennamen - Benennung von Variablennamen:

1. Befolgen Sie die Camel-Case-Namenskonvention (der erste Buchstabe des ersten Wortes ist klein geschrieben und die ersten Buchstaben aller nachfolgenden Wörter sind groß geschrieben).

2. Variablennamen sollten aussagekräftig sein

3. Variablennamen sollten standardisiert werden

4. Schlüsselwörter können nicht verwendet werden (einige mit dem System gelieferte Wörter können nicht verwendet werden)

Variablen deklarieren und initialisieren - Variablen initialisieren - Variablen deklarieren und Werte zuweisen

Deklarieren Sie eine Variable namens num, um die Zahl 100 zu speichern

 Variable Nummer = 110;

Den Wert dieser Variable ausgeben

 alert(num); // Popup-Fenster

Die Browserkonsole befindet sich in der Konsolenoption der Entwicklertools im Browser (Tastenkombination: F12).

console.log(num); // Inhalt in der Browserkonsole ausgeben

Deklarieren Sie mehrere Variablen und weisen Sie ihnen nacheinander Werte zu

var num1,num2,num3;//Deklaration//Werte num1=10 nacheinander zuweisen;   
Zahl2=20;   
Zahl3=30;

Deklarieren mehrerer Variablen und Zuweisen von Werten

Var Num1=10, Num2=20, Num3=30; 
Variable Nummer = 10;
var $break=10;
var shuZi=10;

Hinweis: Alle verarbeiteten Daten befinden sich im Speicher.

• So speichern Sie Daten in js mithilfe von Variablen (Name, Wert -> Daten)
• In js deklarierte Variablen werden alle mit var ----> gespeichert, und die Daten sollten entsprechende Datentypen haben
• Zeichenfolgenwerte in js werden in doppelte oder einfache Anführungszeichen eingeschlossen

04 JS-Variablenfunktion

Die Funktion von Variablen besteht darin, Daten zu speichern oder zu verarbeiten

Variablendeklaration (var hat Variablennamen, aber keinen Wert)

Variableninitialisierung (var hat Variablennamen und -wert)

Methode zur Variablendeklaration:

var-Variablenname;

var number; // Variablendeklaration, derzeit wird kein Wert zugewiesen, 
//Mehrere Variablen gleichzeitig deklarieren var x, y, z, k, j; //Alles sind Deklarationen, es werden keine Werte zugewiesen //Variableninitialisierung (Variablen werden gleichzeitig deklariert und ihnen werden Werte zugewiesen)
// = bedeutet: die Bedeutung der Zuweisung //speichere eine Zahl 10
Variablenzahl = 10; 
//Speichern Sie eine 5
Var Zahl2 = 5; 
//Name einer Person speichern var name = "Xiao Hei"; 
//Wahr speichern
varflag = wahr; 
//Speichere ein Null--->entspricht einer leeren Variable nll = null; 
//Ein Objekt speichern var obj = new Object();

05 JS-Variablen austauschen

Verwenden Sie Variablen von Drittanbietern zum Austauschen

var num1=10; 
var num2=20; 
  // Nimm den Wert der Variablen num1 und füge ihn in die temporäre Variable ein var temp=num1; 
// Nimm den Wert der Variablen num2 und setze ihn in die Variable num1 num1=num2; 
// Nimm den Wert der temporären Variable und setze ihn in die Variable num2 ein num2=temp;
console.log(num1);//20 
console.log(num2);//10

Die zweite Methode des Austauschs: allgemein anwendbar auf den Austausch von Nummern

var num1 = 10;  
var num2 = 20; 
// Nimm den Wert in der Variablen num1 und den Wert in der Variablen num2, addiere sie und weise sie der Variablen num1 neu zu num1 = num1 + num2; //30 
   // Nimm den Wert von num1 und num2 und weise das Ergebnis der Subtraktion num2 zu
        Zahl2 = Zahl1 - Zahl2; // 10 
// Nimm den Wert von num1 und num2 und weise das Ergebnis der Subtraktion num1 zu
        Zahl1 = Zahl1 - Zahl2; // 20
konsole.log(num1, num2);
​

Hinweis: Variablennamen können nicht wiederholt werden, da letztere die ersteren überschreiben würden.

var num1=10; 
Variable Nummer1 = 20; 
konsole.log(num1); 

Erweiterter Variablenaustausch: Schauen Sie sich einfach den Code an, Sie müssen ihn nicht verstehen (Bitoperationen)

var num1 = 10;  
var num2 = 20;  
Zahl1 = Zahl1 ^ Zahl2;  
Zahl2 = Zahl1 ^ Zahl2;  
Zahl1 = Zahl1 ^ Zahl2;  
konsole.log(num1, num2);

06 Kommentare

Kommentarmethode:

• 1. Einzeiliger Kommentar //
• 2. Mehrzeilige Kommentare /**/

//Einzeiliger Kommentar: wird normalerweise über einer Codezeile verwendet

/Mehrzeilige Kommentare: werden im Allgemeinen über einer Funktion oder einem Codeabschnitt verwendet/

//Der kommentierte Code wird nicht ausgeführt //console.log("Haha, ich bin wieder schön"); 
//console.log("zweite Zeile"); 
//Variablen deklarieren und initialisieren //var num=10;

07 JS-Datentypen

Wertetyp (Basistyp):

Zeichenfolge

Zahlen - ganze Zahlen und Dezimalzahlen (Zahl)

Boolescher Wert

Null

Undefiniert

Symbol

Referenzdatentypen:

Objekt

Anordnung

Funktion

Variablennummer; 
console.log(num+10); //NaN-----keine Zahl---->Keine Zahl var num; 
konsole.log(num);
Wie erhält man den Datentyp dieser Variable? Verwenden Sie typeof, um //typeof-Syntax* zu erhalten, um den Datentyp dieser Variable zu erhalten!
     * typeof-Variablenname * typeof (Variablenname)
     * 
varnum = 10; 
var str = "Xiaobai"; 
varflag = wahr; 
var nll = null; 
var undef; 
var obj = neues Objekt();
//Verwenden Sie typeof, um den Typ der Variablen abzurufen console.log(typeof num);//Nummer 
console.log(Typ von str);//Zeichenfolge 
console.log(Typ der Flagge);//Boolesch 
console.log(String(nll));//ist null 
console.log(typeof nll);//Nicht null 
console.log(typeof undef); //undefiniert 
console.log(Objekttyp);//Objekt 
console.log(Typ von(Anzahl));

08 JS digitaler Typ

 // Zahlentyp: Integer und Dezimalzahl var num = 12; 
 num=20; // Ganzzahl num=98,76; // Dezimalzahl (in anderen Sprachen Gleitkommatyp --- Gleitkommazahl mit einfacher Genauigkeit, Gleitkommazahl mit doppelter Genauigkeit) 
 // Alle Zahlen sind vom Typ Zahl

09 Basis

Welche Basen können in js dargestellt werden?

var num=10;//Dezimal

var num2=012;//Oktal

var num3 = 0x123; // hexadezimal

var num=12;//Dezimal console.log(num); 
var num2=012;//Oktal systemconsole.log(num2); 
var num3=0x1a; //hexadezimal console.log(num3); 
varnum=0x1f; 
   konsole.log(num);

Beachten:

Zur Darstellung von Dezimalzahlen: einfach eine normale Zahl Zur Darstellung von Oktalzahlen: beginnen Sie mit 0 Zur Darstellung von Hexadezimalzahlen: beginnen Sie mit 0x

10 NaN

Verwenden Sie NaN nicht, um zu überprüfen, ob es NaN ist

Variablennummer;  
Konsole.log(num+10==NaN); 
console.log("Hallo"=="Mir geht es gut");

Wie kann man überprüfen, ob das Ergebnis NaN ist? Dazu sollte man isNaN() verwenden.

var num; //-----Die Variable wurde deklariert, aber ihr wurde kein Wert zugewiesen. Das Ergebnis lautet: undefined 
 Ist das nicht eine Zahl----->Ist das nicht eine Zahl? NaN--->Keine Zahl console.log(isNaN(10));

Um zu bestimmen, ob das Ergebnis keine Zahl ist, verwenden Sie isNaN(Variablenname).

var str="Hallo"; 
Variablennummer;  
var Summe = Zahl + 10;//NaN 
konsole.log(Summe); 
console.log(isNaN(sum)); // true, wenn es keine Zahl ist, false, wenn es eine Zahl ist

Hinweis: Verwenden Sie nicht NaN, um zu bestimmen, ob es sich um NaN handelt. Sie sollten isNaN (Wert oder Variable) verwenden.

11 Typkonvertierung

1.parseInt();//In Ganzzahl konvertieren

console.log(parseInt("10"));//10 
Konsole.log(parseInt("10afrswfdsf"));//10 
console.log(parseInt("g10")); //NaN 
Konsole.log(parseInt("1fds0"));//1 
console.log(parseInt("10.98"));//10 
Konsole.log(parseInt("10.98fdsfd"));//10

2.parseFloat()//In Dezimalzahlen umwandeln

console.log(parseInt("10"));//10 
Konsole.log(parseInt("10afrswfdsf"));//10 
console.log(parseInt("g10")); //NaN 
Konsole.log(parseInt("1fds0"));//1 
console.log(parseInt("10.98"));//10 
Konsole.log(parseInt("10.98fdsfd"));//10

3.Number(); //In Zahlen umwandeln

console.log(Zahl("10"));//10  
console.log(Zahl("10afrswfdsf")); //NaN 
console.log(Zahl("g10")); //NaN 
console.log(Zahl("1fds0")); //NaN 
console.log(Zahl("10.98"));//10.98 
console.log(Zahl("10.98fdsfd"));//NaN

Hinweis: Wenn Sie eine Ganzzahl konvertieren möchten, verwenden Sie parseInt(); wenn Sie eine Dezimalzahl konvertieren möchten, verwenden Sie parseFloat()

Möchten Sie Zahlen konvertieren: Number(); ist strenger als die beiden obigen Methoden

Andere Typen zu Zeichenfolgentypen

1. toString()

// varnum = 10; 
// console.log(num.toString());//String-Typ// //2 String(); 
// var num1 = 20; 
// konsole.log(String(num1));

Wenn die Variable sinnvoll ist, rufen Sie .toString() auf, um sie zu konvertieren. Wenn die Variable keinen Sinn ergibt, verwenden Sie String(), um sie zu konvertieren.

Variable Nummer2; 
console.log(num2.toString()); 
var num3=null; 
console.log(num3.toString()); 
    //Dies kann var num2 sein; 
console.log(Zeichenfolge(num2)); 
var num3=null; 
console.log(Zeichenfolge(num3));
​

Andere Typen zu Booleschen Typen

console.log(Boolean(1)); //wahr 
console.log(Boolean(0));//falsch 
console.log(Boolean(11));//wahr 
console.log(Boolean(-10));//wahr 
console.log(Boolean("Überprüfen"));//true 
console.log(Boolean(""));//falsch 
console.log(Boolean(null));//falsch 
console.log(Boolean(undefiniert)); //falsch

12 JS-Grundcodestandards

• Deklarieren Sie Variablen in js mit var
• Jede Codezeile in js sollte mit einem Semikolon enden; (es ist üblich, beim Schreiben von Code Semikolons zu verwenden)
• js unterscheidet zwischen Groß- und Kleinschreibung: var N=10; n
• Zeichenfolgen in JS können einfache oder doppelte Anführungszeichen verwenden. Im Moment verwenden wir doppelte Anführungszeichen.

Oben finden Sie die äußerst detaillierten grundlegenden Grammatikregeln von JavaScript. Weitere Informationen zu den Grammatikregeln von JavaScript finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!