Fassen Sie die grundlegende Syntax von JavaScript zusammen und organisieren Sie sie

Autor：Eve Cole Aktualisierungszeit：2022-08-08 08:55:00

Dieser Artikel vermittelt Ihnen relevantes Wissen über JavaScript, das hauptsächlich Fragen im Zusammenhang mit der grundlegenden Syntax behandelt. JavaScript ist die beliebteste Skriptsprache im Internet. Ich hoffe, dass es für alle hilfreich ist.

Einführung

JavaScript ist die beliebteste Skriptsprache im Internet. Diese Sprache kann für HTML und Web verwendet werden und ist auf Servern, PCs, Laptops, Tablets, Smartphones und anderen Geräten weit verbreitet.

Funktionen von JavaScript

JavaScript ist eine Skriptsprache.
JavaScript ist eine leichte Programmiersprache.
JavaScript ist Programmiercode, der in HTML-Seiten eingefügt werden kann.
Wenn JavaScript in eine HTML-Seite eingefügt wird, kann es von allen modernen Browsern ausgeführt werden.
JavaScript ist leicht zu erlernen.

JavaScript wurde von ECMA (European Computer Manufacturers Association) durch ECMAScript als Sprache standardisiert.

Jahr	Name	Beschreibung
1997	ECMAScript 1	Erste Version
1998	ECMAScript 2	Versionsänderungen
1999	ECMAScript 3	Regulären Ausdruck hinzufügen Try/Catch hinzufügen
	ECMAScript 4	wird nicht veröffentlicht.
2009	ECMAScript 5	fügt den „strikten Modus“ hinzu.
2011	ECMAScript	6
fügt	Klassen	und Module hinzu
(	**	)

Die Verwendung

von Array.prototype.includes

muss in HTML zwischen den Tags <script> und </script> stehen. Skripte können in den Abschnitten <body> und <head> einer HTML-Seite platziert werden.

Oft müssen wir Code ausführen, wenn ein Ereignis eintritt, beispielsweise wenn der Benutzer auf eine Schaltfläche klickt. Wenn wir den JavaScript-Code in eine Funktion einfügen, können wir die Funktion aufrufen, wenn das Ereignis eintritt.

Beispiel 1: Skriptfunktion im Head

<!DOCTYPE html>
<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>Skript im Head-Tag</title>
    <Skript>
        Funktion myFunction() {
            document.getElementById("demo").innerHTML = "Das ist meine Funktion";
        }
    </script>
</head>
<Körper>
<h1>Meine Funktion</h1>
<p id="demo">Ein Absatz</p>
<button type="button" onclick="myFunction()">Dies ist eine Funktion</button>
</body>
</html>

Beispiel 2: Skriptfunktion im Textkörper

<!DOCTYPE html>
<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>Skript im Text</title>
</head>
<Körper>
<h1>Meine Funktion</h1>
<p id="demo">Meine Funktion</p>
<button type="button" onclick="myFunction()">Klick</button>
<Skript>
    Funktion myFunction() {
        document.getElementById("demo").innerHTML = "Das ist meine Funktion"
    }
</script>
</body>
</html>

JavaScript kann auch extern zum Aufrufen platziert werden. Beachten Sie, dass die externe Erweiterung .js ist.

Beispiel 3: Externer Aufruf der JavaScriptExternal

call.js

-Funktion myFunction() {
    document.getElementById('demo').innerHTML = "Das ist meine Funktion"
}

Rufen Sie das externe Skript

<!DOCTYPE html>

auf

<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>Externes Skript aufrufen</title>
</head>
<Körper>
<p id="demo">Ein Textabsatz</p>
<button type="button" onclick="myFunction()">Probieren Sie es aus</button>
<script src="external script.js"></script>
</body>
</html>

JavaScript-

Ausgabedaten

können auf verschiedene Arten ausgegeben werden:

Verwenden Sie window.alert(), um ein Warnfeld anzuzeigen.
Verwenden Sie die Methode document.write(), um Inhalte in ein HTML-Dokument zu schreiben.
Verwenden Sie innerHTML, um in HTML-Elemente zu schreiben.
Verwenden Sie console.log(), um in die Konsole des Browsers zu schreiben.

Beispiel 1: Ausgabe des Popup-Fensters aler()

<!DOCTYPE html>
<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>Warnungsausgabe</title>
</head>
<Körper>
<h1>Warnungsausgabe</h1>
<Skript>
    window.alert(5 + 6)
</script>
</body>
</html>

Beispiel 2: document.write() Ausgabe

<!DOCTYPE html>
<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>document.write-Ausgabe</title>
</head>
<Körper>
<h1>document.write-Ausgabe</h1>
<Skript>
    document.write(Date());
    document.write("Hallo,Web!");
</script>
</body>
</html>

Beispiel 3: Schreiben Sie in ein HTML-Dokument

<!DOCTYPE html>
<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>In HTML-Dokument schreiben</title>
</head>
<Körper>
<h1>In HTML-Dokument schreiben</h1>
<Skript>
    Funktion myFunction() {
        document.write("Funktionsausgabe");
    }
</script>
<button onclick="myFunction()">Klicken Sie hier</button>
</body>
</html>

Beispiel 4: Verwenden Sie console.log(), um in die Konsole

<!DOCTYPE html>

des Browsers zu schreiben

<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>Verwenden Sie console.log(), um in die Konsole des Browsers zu schreiben</title>
</head>
<Körper>
<h1>console.log() schreibt in die Konsole des Browsers</h1>
<Skript>
    a = 5;
    b = 6;
    c = a + b;
    console.log(c)
</script>
</body>
</html>

Syntax-Einführung

JavaScript ist eine Skriptsprache. Es ist eine leichte, aber leistungsstarke Programmiersprache.

Literale

In Programmiersprachen werden im Allgemeinen feste Werte als Literale bezeichnet.

Zahlenliteral: Es kann eine Ganzzahl oder eine Dezimalzahl oder eine wissenschaftliche Notation (e) sein. Wie 3,14, 5,88 usw.
String-Literal: „ Sie können einfache oder doppelte Anführungszeichen verwenden. Zum Beispiel „Hallo“, „Web“ usw.
Ausdrucksliteral: fester Wert für die Berechnung. 3 + 2,2, 3,14 * 2 usw.
Array (Array): Literal: Definieren ein Array. Wie [1,2,3,4,5,6].
Objekt: Literal: Definieren Sie ein Objekt wie {firstName: „John“, lastName: „Doe“, age: 50, eyeColor: „blue "}.
Funktionsliteral: Definieren Sie eine Funktion. Zum Beispiel function myFunction(a, b) { return a * b;}.

Beachten Sie, dass in JavaScript die Anweisung mit „;“ abgeschlossen werden muss. JavaScrip-

Variablen

In Programmiersprachen Variablen werden zum Speichern von Datenwerten verwendet. JavaScript verwendet das Schlüsselwort var, um Variablen zu definieren, und verwendet das Gleichheitszeichen, um Variablen gegenseitig Werte zuzuweisen:

var y = false // Boolescher Wert var length = 16; // Anzahl var Punkte = x * 10; // Anzahl Berechnung var lastName = "Johnson"; // String var cars = ["Saab", "Volvo", "BMW"]; „John“, lastName:“Doe“}; // Objektwörterbuch

JavaScript-Funktion

Um wiederholt auf dieselbe Funktion zu verweisen und den Komfort beim Schreiben und Warten von Code zu verringern, stellt JavaScript Funktionsfunktionen bereit, die durch das Schlüsselwort function:

function myFunc (a , B) {
    return a + b; // Das Ergebnis von a+b zurückgeben}

JavaScript-Funktionen

Im Vergleich zu anderen Sprachen verfügt JavaScript über die folgenden Funktionen:

Bei JavaScript wird die Groß-/Kleinschreibung beachtet.
JavaScript verwendet den Unicode-Zeichensatz.
JavaScript empfiehlt die Verwendung von Camel Case-Benennung, um Variablen zu definieren und Schlüsselwörter bei der Benennung zu vermeiden.
JavaScript ist eine schwach typisierte Sprache und Variablen werden mit dem Schlüsselwort var definiert.

JavaScript-Schlüsselwörter (in alphabetischer Reihenfolge)
abstrakt	else	Instanz von	super
boolean	enum	int	Schalter
Pause	Export	Schnittstelle	synchronisiert
Byte	erweitert	Let	dieser
Fall	falsch	langer	Wurf
Catch	final	native	Würfe
char	endlich	neue	transiente
Klasse	Float	null	wahr
const	für	Paket	versuchen
Fortsetzung	Funktion	privat	Typ
des Debuggers	goto	geschützt	var
default	if	public	void
delete	implementiert	return	volatile
do	import	short	while
double	in	static	mit

JavaScript-Kommentar (wie Java)

// Dies ist der Code: Einzelsatzkommentar, normalerweise Strg + L-Taste im Editor.

/* Dies ist der Code*/: Mehrzeilige Kommentare, normalerweise Strg + Umschalt + L-Tasten im Editor.

Anweisungen

JavaScript-Anweisungen sind an den Browser ausgegebene Befehle, die dem Browser mitteilen, was er tun soll. Die folgende JavaScript-Anweisung gibt den Text „Hello World!“ an das HTML-Element mit id="demo" aus:

document.getElementById("demo").innerHTML =

Hello World!";

geschweifte Klammern, das ist Java sehr ähnlich.

Java Identifier

Der Der Funktionsschalterthrow

Common JavaScript Identifier
Statement	Beschreibung
break	wird verwendet, um aus einer Schleife auszubrechen.
Catch	-Anweisungsblock wird ausgeführt, wenn während der Ausführung des Try-Anweisungsblocks ein Fehler auftritt.
continue	überspringt eine Iteration in der Schleife.
do ... while	führt einen Anweisungsblock aus und setzt die Ausführung des Anweisungsblocks fort, wenn die bedingte Anweisung wahr ist.
for	kann den Codeblock eine bestimmte Anzahl von Malen ausführen, wenn die bedingte Anweisung wahr ist.
for ... in	wird verwendet, um die Eigenschaften eines Arrays oder Objekts zu durchlaufen (eine Schleife durch die Eigenschaften eines Arrays oder Objekts).
Funktion	definiert eine Funktion
if...else,	um verschiedene Aktionen basierend auf unterschiedlichen Bedingungen auszuführen.
Return-	Exit-
wird	verwendet, um verschiedene Aktionen basierend auf unterschiedlichen Bedingungen auszuführen.
löst	(erzeugt) einen Fehler aus.
try	implementiert die Fehlerbehandlung und wird zusammen mit Catch verwendet.
var	deklariert eine Variable.
while	Wenn die bedingte Anweisung wahr ist, führen Sie den Anweisungsblock aus.

Die meisten Sprachen können Leerzeichen automatisch vervollständigen, um es klarer und schöner zu machen. Sie sollten jedoch auf die Verwendung von Leerzeichen in HTML achten und nicht herumspielen. In JavaScript sind die folgenden zwei Sätze gleich:

var a = 10;
var b=10;

Ähnlich wie Python ist auch JavaScript eine Skriptsprache und wird interpretiert.

Objektdefinition

Objekt

Alles ist ein Objekt, eine abstrakte Instanz von Merkmalen unter Dingen mit denselben Merkmalen. Wie Xiao Ming unter Menschen.

In JavaScript ist ein Objekt ein Container mit Attributvariablen, ähnlich einem Wörterbuch in Python oder einer Hash-Map in Java, das die Attribute des Objekts definiert.

var people = {
    Vorname: „Mike“,
    Nachname: „Smith“,
    Alter: „18“,
    Adresse: „Peking“,
    Beruf: „Student“
};

Das Obige ist die Objektdefinition, die Sie der Schönheit halber auch in einer Zeile schreiben können, und ich fordere jeden auf, in Zukunft so zu schreiben.

Um auf Objekteigenschaften zuzugreifen,

können wir sagen: „JavaScript-Objekte sind Container für Variablen“. Normalerweise stellen wir uns jedoch „JavaScript-Objekte als Container von Schlüssel-Wert-Paaren“ vor. Schlüssel-Wert-Paare werden normalerweise als Schlüssel:Wert geschrieben (Schlüssel und Wert werden durch Doppelpunkt getrennt) und werden in JavaScript-Objekten normalerweise als Objekteigenschaften bezeichnet. Wir greifen auch über das universelle „.“ auf Eigenschaften zu (die meisten Sprachen verwenden dies).

<!DOCTYPE html>
<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>Dies ist die Website</title>
</head>
<Körper>
<h1>Auf Klassenattribute zugreifen</h1>
<!--Die folgende Anweisung muss vor script--> stehen
<p id="demo"></p>
<Skript>
    var people = {
        Vorname: „Mike“,
        Nachname: „Smith“,
        Alter: „18“,
        Adresse: „Peking“,
        Beruf: „Student“
    };
    document.getElementById("demo").innerHTML =
        people["firstName"] + "." + people.lastName;
</script>
</body>
</html>

Zwei Zugriffsmethoden: Sie können Objektname.Eigenschaft oder Objektname.["Eigenschaft"] verwenden.

Funktion

Eine Funktion ist ein ereignisgesteuerter oder wiederverwendbarer Codeblock, der ausgeführt wird, wenn er aufgerufen wird. Wenn diese Funktion aufgerufen wird, wird der Code innerhalb der Funktion ausgeführt. Funktionen können direkt aufgerufen werden, wenn ein Ereignis auftritt (z. B. wenn der Benutzer auf eine Schaltfläche klickt) und können von überall aus über JavaScript aufgerufen werden.

Parameter und Rückgabewerte

Wenn Sie eine Funktion aufrufen, können Sie ihr Werte, sogenannte Parameter, übergeben, und die Anzahl der Parameter ist unbegrenzt.

Funktion myFunction( var1 , var2 )
{
Code
}

Beim Aufrufen von Parametern sollten diese in strikter Übereinstimmung mit ihrer Reihenfolge übergeben werden, wie unten gezeigt:

<!DOCTYPE html>
<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>Dies ist eine JavaScript-Website</title>
</head>
<Körper>
<h1>Problem bei der Übergabe von Funktionsparametern</h1>
<p>Klicken Sie zum Anrufen auf die Schaltfläche unten</p>
<button onclick="myFunc('Mike','18','Beijing')">Klicken Sie hier</button>
<Skript>
    Funktion myFunc(Name, Alter, Adresse) {
        Alert("Mein Name ist " + Name + ", mein Alter ist " + Alter + " und mein Zuhause ist in " + Adresse);
    }
</script>
</body>
</html>

JavaScript-Funktionen dürfen Rückgabewerte haben und das Schlüsselwort „return“ lautet „return“. Wenn die Funktion einen Wert zurückgibt, stoppt die Ausführung der Funktion und die Anweisungen nach der Rückgabe werden nicht ausgeführt.

Beispiel: Berechnen Sie das Produkt zweier Zahlen und geben Sie das Ergebnis

<!DOCTYPE html>

zurück

<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>JavaScript-Website</title>
</head>
<Körper>
<h1>Berechnen Sie den Wert zweier Zahlen und geben Sie zurück</h1>
<p id="demo"></p>
<Skript>
    Funktion myFunc(a, b) {
        return a * b;
    }

    document.getElementById("demo").innerHTML = myFunc(3, 4);
</script>
</body>
</html>

Variablen

JavaScript-Variablen werden in zwei Typen unterteilt:

Globale Variablen: Außerhalb der Funktion deklarierte Variablen sind globale Variablen, auf die alle Skripts und Funktionen auf der Webseite zugreifen können.
Lokale Variablen: Eine innerhalb einer JavaScript-Funktion deklarierte Variable (mithilfe von var) ist eine lokale Variable, daher kann nur innerhalb der Funktion auf sie zugegriffen werden.

Wenn wir einer nicht deklarierten JavaScript-Variablen einen Wert zuweisen, wird die Variable automatisch als Eigenschaft von window behandelt. Beispielsweise deklariert die folgende Anweisung:

name = „Mike“

den Attributnamen „window“. Globale Variablen, die durch Zuweisen von Werten zu nicht deklarierten Variablen im nicht strengen Modus erstellt werden, sind konfigurierbare Attribute des globalen Objekts und können gelöscht werden. Zum Beispiel:

var var1 = 1; // Globale Eigenschaften können nicht konfiguriert werden var2 = 2; // Ohne var-Deklaration können globale Eigenschaften konfiguriert werden console.log(this.var1);
console.log(window.var1); // 1

delete var1; // false kann console.log(var1); //1 nicht löschen

var2 löschen; 
console.log(var2 löschen); // true
console.log(var2); // Fehlervariable wurde gelöscht Undefinierte

Ereignisbeschreibung

HTML-Ereignisse sind Dinge, die auf HTML-Elementen passieren. Wenn JavaScript in HTML-Seiten verwendet wird, kann JavaScript diese Ereignisse auslösen.

HTML-Ereignisse können Browseraktionen oder Benutzeraktionen sein. Im Folgenden sind Beispiele für HTM-Ereignisse aufgeführt:

Die HTML-Seite wird geladen.
Das HTML-Eingabefeld ändert sich
.

Wenn ein Ereignis auftritt, können Sie normalerweise etwas tun. JavaScript kann Code ausführen, wenn ein Ereignis ausgelöst wird. Ereignisattribute können zu HTML-Elementen hinzugefügt werden und JavaScript-Code kann zum Hinzufügen von HTML-Elementen verwendet werden.

Einfache Anführungszeichen: < some-HTML-element some-event = ' JavaScript code ' >
Doppelte Anführungszeichen: < some-HTML-element some-event = " JavaScript code " >

<!DOCTYPE html>
<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>JavaScript-Ereignis</title>
</head>
<Körper>
<h1>Zwei Möglichkeiten, JavaScript-Ereignisse zu verarbeiten</h1>
<p id="demoOne"></p>
<button onclick="getElementById('demoOne').innerHTML=Date()">Klicken Sie hier, um Zeit 1 anzuzeigen</button>
<p id="demoTwo"></p>
<button onclick="this.innerHTML=Date()">Klicken Sie hier, um Zeit 2 anzuzeigen</button>
</body>
</html>

JavaScript ist normalerweise mehrzeiliger Code, und der weniger verbreitete Code wird über Ereignisattribute aufgerufen.

<!DOCTYPE html>
<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <title>JavaScript-Ereignis</title>
</head>
<Körper>
<h1>JavaScript-Ereignisattributaufruf</h1>
<p>Klicken Sie, um die Funktion <em>myFunc()</em> auszuführen</p>
<button onclick="myFunc()">Klicken Sie hier</button>
<p id="one"></p>
<Skript>
    Funktion myFunc() {
        document.getElementById("one").innerHTML = Date();
    }
</script>
</body>
</html>

Häufige HTML-Ereignisse
Ereignisbeschreibung	onchange
HTML	-Elementänderungen
onclick	Der Benutzer klickt auf das HTML-Element
onmouseover	Der Benutzer bewegt die Maus über ein HTML-Element
onmouseout	Der Benutzer bewegt die Maus von einem HTML-Element weg
onkeydown	Der Benutzer drückt die Tastaturtaste
onload	Der Browser hat die Seite fertiggestellt. Nach dem Laden werden weiterhin weitere Ereignisse gelernt

Ereignisrolle

Ereignisse können zur Handhabung von Formularvalidierung, Benutzereingaben, Benutzerverhalten und Browseraktionen verwendet werden:

Ereignisse werden ausgelöst, wenn die Seite geladen wird,
Ereignisse werden ausgelöst, wenn die Seite geschlossen wird,
der Benutzer auf die Schaltfläche klickt, um Aktionen auszuführen,
und zur Überprüfung Um die Legitimität des Benutzereingabeinhalts zu gewährleisten,

können mehrere Methoden zum Ausführen von JavaScript-Ereigniscode verwendet werden:

HTML-Ereignisattribut
kann JavaScript-Funktionen angeben
.
Sie können das Auftreten von Ereignissen verhindern.

Zeichenfolge

: Eine Sammlung von Zeichen.

var a = "abc";
var b = „Hallo“;

Ähnlich wie bei Python kann auf jedes Zeichen in der Zeichenfolge über einen Index zugegriffen werden:

var c = b[1] // e

length

Diese Eigenschaft kann die Länge der Zeichenfolge berechnen.

<!DOCTYPE html>
<html>
<Kopf>
    <meta charset="utf-8">
    <title>Stringlänge</title>
</head>
<Körper>
<Skript>
    var txtOne = "Hallo Welt!";
    document.write("<p>" + txtOne.length + "</p>");
    var txtTwo = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    document.write("<p>" + txtTwo.length + "</p>");
</script>
</body>
</html>

JavaScript hat auch einige Sonderzeichen. Wenn wir beispielsweise Anführungszeichen drucken möchten, müssen wir „“ als Escapezeichen hinzufügen, da der Compiler sie sonst nicht analysieren kann.

Zeichenfolge

Häufiger JavaScript-Sonderzeichencode.
Ausgabe
'	einfaches Anführungszeichen
"	doppeltes Anführungszeichen
\	Backslash
nline	Feed
rcarriage	return
ttab	(Tab-Zeichen)
bbackspace	-Zeichen
	fformfeed-

als Objekt

. Normalerweise sind JavaScript-Zeichenfolgen primitive Werte und kann mit den folgenden Zeichen erstellt werden: var firstName = „Mike“, aber wir können auch das Schlüsselwort new verwenden, um einen String als Objekt zu definieren: var firstName = new String(“Mike“), was den

ähnelt Eigenschaftslänge .

Eigenschaftsbeschreibung	Konstruktor
gibt	die Funktion zurück, die die Zeichenfolge erstellt.
gibt	die Länge des Zeichenfolgenprototyps zurück.
Ermöglicht	das Hinzufügen von Eigenschaften und Methoden zur Objektzeichenfolge

in Großbuchstaben

Allgemeine Methoden.
Methodenbeschreibung	.
charAt()	gibt das Zeichen an der angegebenen Indexposition zurück.
charCodeAt()	gibt Specify zurück Der Unicode-Wert des Zeichens an der Indexposition
verkettet	zwei oder mehr Zeichenfolgen und gibt die verbundene Zeichenfolge zurück.
fromCharCode	()
gibt	die Position zurück, an der das angegebene Zeichen zum ersten Mal erscheint Die Zeichenfolge.
lastIndexOf()	gibt die Position des letzten Vorkommens des angegebenen Zeichens in der Zeichenfolge zurück.
localeCompare()	verwendet eine lokal spezifische Reihenfolge, um zwei Zeichenfolgen zu vergleichen.
match()	findet eine Übereinstimmung mit einem oder mehreren regulären Ausdrücken.
replace()	ersetzt durch a regulärer Ausdruck Passende Teilzeichenfolge
search()	ruft den Wert ab, der mit dem regulären Ausdruck übereinstimmt.
Slice()	extrahiert ein Fragment der Zeichenfolge und gibt den extrahierten Teil in einer neuen Zeichenfolge zurück.
split()	teilt die Zeichenfolge in ein Array von Teilzeichenfolgen auf.
substr ()	Extrahiert das angegebene Anzahl der Zeichen in der Zeichenfolge aus der Startindexnummer
substring ()	Extrahieren Sie die Zeichen zwischen den beiden angegebenen Indexnummern in der Zeichenfolge
toLocaleLowerCase ()	Wandeln Sie die Zeichenfolge entsprechend dem Gebietsschema des Hosts in Kleinbuchstaben um. Es gibt nur wenige Sprachen (z. B. Türkisch) verfügen über eine lokalspezifische Groß-/Kleinschreibungszuordnung
zu LocaleUpperCase (),	um Zeichenfolgen entsprechend dem Gebietsschema des Hosts in Großbuchstaben umzuwandeln. Nur wenige Sprachen (z. B. Türkisch) verfügen über eine lokalspezifische Groß-/Kleinschreibungszuordnung
zu LowerCase (),	um Zeichenfolgen zu konvertieren
In Kleinbuchstaben umwandeln
toString()	Gibt den String-Objektwert zurück
toUpperCase()	Konvertiert den String in Großbuchstaben
trim()	Entfernen Sie die führenden und nachgestellten Leerzeichen des Strings
valueOf()	Gibt den ursprünglichen Wert eines String-Objekts zurück

== und === Unterschied

1. Für Grundtypen wie Zeichenfolge und Zahl gibt es einen Unterschied

zwischen == und === a) Vergleich zwischen verschiedenen Typen: == vergleicht „Werte nach der Konvertierung in denselben Typ“, um festzustellen, ob die „Werte " sind gleich, === wenn die Typen unterschiedlich sind, ist das Ergebnis ungleich.
b) Bei Vergleichen desselben Typs führt ein direkter „Wert“-Vergleich zum gleichen Ergebnis.

2. Für erweiterte Typen wie Array und Object gibt es keinen Unterschied zwischen == und ===

für

„Zeigeradressen“-Vergleich.

3. Es gibt einen Unterschied zwischen Basistypen und erweiterten Typen

Erweiterter Typ zum Basistyp und Durchführung eines „Wert“-Vergleichs
b) Da die Typen unterschiedlich sind, ist das ===-Ergebnis falsch

4. != ist die Nicht-Operation von ==, !== ist die Nicht-Operation von = ==

var num=1;

var str="1";

var test=1;

test == num //true gleicher Typ und gleicher Wert test === num //wahr gleicher Typ und gleicher Wert test !== num //false test hat den gleichen Typ wie num und sein Wert ist auch derselbe Nichtoperation muss falsch sein 

num == str //true Konvertieren Sie str in eine Zahl und prüfen Sie, ob sie gleich ist. 

num != str //false == Nichtoperation num === str //false Der Typ ist unterschiedlich und gibt false direkt zurück 

num !== str //true Die unterschiedlichen Typen von num und str bedeuten, dass sie nicht gleich sind. Die Nicht-Operation ist natürlich wahr.

Operator-

Beschreibung x

für JavaScript-Operatoren (y=5)
Operator-Beschreibungsbeispiel	x	Operationsergebnis	y	Operationsergebnis
+	Addition	x =y+2	7	5
-Subtraktion	x	=y-2	3	5
*	Multiplikation	x=y*2	10	5
/	Division	x=y/2	2,5	5
%	Modulo (Rest)	x=y%2	1	5
++	Inkrement	x =++y	6	6
++	Inkrement	x=y++	5	6
--decrement	=	--y	4	4
--decrement	=	x=y--	5	4

Häufige JavaScript-Zuweisungsoperatoren (x=10, y=5)
Operatorbeispiele	sind	äquivalent zu	Operationen Ergebnis
=	x =y		x=5
+=	x+=y	x=x+y	x=15
-=	x-=y	x=xy	x=5
*=	x*=y	x=x*y	x=50
/=	x/=y	x= x/y	x=2
%=	x%=y	x=x%y	x=0

Gemeinsame JavaScript-Vergleichsoperatoren (x=5)
Operatorbeschreibung	Vergleichsrückgabewert	==	gleich
x	==	8	falsch
x	==	x==5	wahr
= = =	Absolut gleich (Wert und Typ sind gleich)	x==="5"	falsch
= = =	Absolut gleich (Wert und Typ sind gleich)	x===5	wahr
!=	ungleich	x!=8	wahr
!==	Nicht absolut gleich (Wert und Typ sind nicht gleich	gleich oder beide sind ungleich)	x!=="5"	wahr
!==	Nicht absolut gleich (Wert und Typ sind nicht gleich	gleich oder beide sind ungleich)	x!==5	falsch
>	größer als	x>8	falsch
<	kleiner als	x<8	wahr
>=	größer oder gleich	x>=8	falsch
<=	kleiner oder gleich	x<= 8	wahr
<=	kleiner oder gleich	x<=8	wahr

JavaScript-gängige logische Operatoren (x=6, y=3)
Operatorbeschreibungsbeispiele	&&	und
(	x	< 10 && y > 1) ist true
\|\|.	or	(x== 5 \|\| y==5) is false
!	not	!(x==y) is true

JavaScript enthält auch bedingte Operatoren, die Variablen basierend auf bestimmten Bedingungen Werte zuweisen. Zum Beispiel:

Variablenname=(Bedingung)?Wert1:Wert2

Bedingte Beurteilung

In JavaScript können wir die folgenden bedingten Anweisungen verwenden:

if-Anweisung – nur wenn die angegebene Bedingung wahr ist, verwenden Sie diese Anweisung, um den Code auszuführen
if...else-Anweisung – Wenn die Bedingung erfüllt ist, führen Sie Code aus, wenn sie wahr ist, und anderen Code, wenn die Bedingung falsch ist.
if...else if...else-Anweisung – Verwenden Sie diese Anweisung, um einen von mehreren Codeblöcken zur Ausführung auszuwählen.
switch-Anweisung – Verwenden Sie diese Anweisung, um mehrere auszuwählen Der Codeblock zum Ausführen

der if-Anweisung

führt den Code nur aus, wenn die Bedingung wahr ist. Beispiel:

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>JavaScript-Website</title>
</head>
<Körper>
<h1>Dies ist eine if-Anweisung</h1>
<button onclick="myFunc()">Klicken Sie hier</button>
<p id="one"></p>
<Skript>
    Funktion myFunc() {
        var x = "";
        var time = new Date().getHours();
        if (Zeit < 20) {
            x = „Hallo, vor 20:00“;
        }
        document.getElementById("one").innerHTML = x;
    }
</script>
</body>
</html>

if...else-Anweisung

Verwenden Sie die if...else-Anweisung, um Code auszuführen, wenn die Bedingung wahr ist, und anderen Code, wenn die Bedingung falsch ist.

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>JavaScript-Website</title>
</head>
<Körper>
<h1>Dies ist eine if...else-Anweisung</h1>
<button onclick="myFunc()">Klicken Sie hier</button>
<p id="one"></p>
<Skript>
    Funktion myFunc() {
        var x = "";
        var time = new Date().getHours();
        if (Zeit < 20) {
            x = „Hallo, vor 20:00“;
        }anders {
            x = „Hallo, nach 20:00“;
        }
        document.getElementById("one").innerHTML = x;
    }
</script>
</body>
</html>

Mehrere if..else-Anweisungen

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>JavaScript-Website</title>
</head>
<Körper>
<h1>Mehrere if...else-Anweisungen</h1>
<button onclick="myFunc()">Klicken Sie hier</button>
<p id="one"></p>
<Skript>
    Funktion myFunc() {
        var x = "";
        var time = new Date().getHours();
        if (Zeit < 12) {
            x = „Guten Morgen“;
        } else if (time < 14) {
            x = „Guten Tag“;
        }
        anders {
            x = „Guten Tag“;
        }
        document.getElementById("one").innerHTML = x;
    }
</script>
</body>
</html>

switch-Anweisung

Verwenden Sie die switch-Anweisung, um einen von mehreren auszuführenden Codeblöcken auszuwählen. Beispiel:

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>JavaScript-Website</title>
</head>
<Körper>
<h1>switch-Anweisung</h1>
<button onclick="myFunc()">Klicken Sie hier</button>
<p id="one"></p>
<Skript>
    Funktion myFunc() {
        var x = "";
        var time = new Date().getMonth();
        Schalter (Zeit) {
            Fall 0:
                x = „Januar“;
                brechen;
            Fall 1:
                x = „Februar“;
                brechen;
            Fall 2:
                x = „März“;
                brechen;
            Fall 3:
                x = „April“;
                brechen;
            Fall 4:
                x = „Mai“;
                brechen;
            Fall 5:
                x = „Jane“;
                brechen;
            Fall 6:
                x = „Juli“;
                brechen;
            Fall 7:
                x = „August“;
                brechen;
            Fall 8:
                x = „September“;
                brechen;
            Fall 9:
                x = „Oktober“;
                brechen;
            Fall 10:
                x = „November“;
                brechen;
            Fall 11:
                x = „Dezember“;
                brechen;
            Standard:
                x = „FEHLER“;
        }
        document.getElementById("one").innerHTML = x;
    }
</script>
</body>
</html>

Schleife

JavaScript unterstützt verschiedene Arten von Schleifen:

for – durchläuft einen Codeblock eine bestimmte Anzahl von Malen.
for/in – durchläuft die Eigenschaften des Objekts in einer Schleife.
while – durchläuft den angegebenen Codeblock in einer Schleife, wenn die angegebene Bedingung wahr ist
. do/while – auch wenn angegeben. Wenn die Bedingung wahr ist, wird der angegebene Codeblock

für die Schleife

<!DOCTYPE html>

in einer Schleife ausgeführt

<html>
<Kopf>
    <meta charset="utf-8">
    <title>JavaScript-Schleife</title>
</head>
<Körper>
<h1>Klicken Sie auf die Schaltfläche, um den Code fünfmal zu wiederholen. </h1>
<button onclick="myFunc()">Klicken Sie hier</button>
<p id="demo"></p>
<Skript>
    Funktion myFunc() {
        var x = "";
        für (var i = 0; i < 5; i++) {
            x = x + „Die Zahl ist“ + i + „<br>“;
        }
        document.getElementById("demo").innerHTML = x;
    }
</script>
</body>
</html>

für /in-Schleife

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>
<p>Klicken Sie auf die Schaltfläche unten, um die Personenattribute des Objekts zu durchlaufen</p>
<button onclick="myFunc()">Klicken Sie hier</button>
<p id="one"></p>
<Skript>
    Funktion myFunc() {
        sei x;
        let text = "";
        const person = {
            Vorname: „Bill“,
            Nachname: „Gates“,
            Alter: 56
        };
        für (x persönlich) {
            text = text + " " + person[x];
        }
        document.getElementById("one").innerHTML = text;
    }
</script>
</body>
</html>

while-Schleife

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>
<p>Klicken Sie auf die Schaltfläche und die Ausgabe wird gedruckt, wenn i kleiner als 5 ist</p>
<button onclick="myFunc()">Klicken Sie hier</button>
<p id="one">Hier anzeigen</p>
<Skript>
    Funktion myFunc() {
        sei x = "", i = 0;
        while (i < 5) {
            x = x + „Diese Zahl ist“ + i + „<br>“;
            i++;
        }
        document.getElementById("one").innerHTML = x
    }
</script>
</body>
</html>

do/while-Schleife

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>
<p>Klicken Sie auf die Schaltfläche, um eine Zahl kleiner als 5 zu drucken</p>
<button onclick="myFunc()">Klicken Sie hier</button>
<p id="one"></p>
<Skript>
    Funktion myFunc() {
        sei x = "";
        sei i = 0;
        Tun {
            x = x + „Die Zahl ist“ + i + „<br>“;
            i++;
        }
        while (i < 5);
        document.getElementById("one").innerHTML=x;
    }
</script>
</body>
</html>

Vergleich zwischen for-Schleife und while-Schleife

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>

<p>Das ist funcOne</p>
<button onclick="funcOne()">Klicken Sie auf funcOne</button>
<p id="one">funcOne ist da</p>

<p>Das ist funcTwo</p>
<button onclick="funcTwo()">Klicken Sie auf funcTwo</button>
<p id="two">funcTwo ist da</p>

<Skript>
    Funktion funcOne() {
        Zahlen = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        sei i = 0;
        sei addRes = 0;
        while (Zahlen[i]) {
            addRes += Zahlen[i];
            i++;
        }
        document.getElementById("one").innerHTML = addRes + "<br>";

    }

    Funktion funcTwo() {
        Zahlen = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        sei i = 0;
        sei mulRes = 1;
        for (; zahlen[i];) {
            mulRes *= Zahlen[i];
            i++;
        }
        document.getElementById("two").innerHTML = mulRes + "<br>";
    }
</script>

</body>
</html>

Break- und Continue-

Break-Anweisungen werden zum Ausbrechen von Schleifen verwendet. continue wird verwendet, um eine Iteration in einer Schleife zu überspringen.

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>
<p>Dies sind die continue- und break-Anweisungen</p>
<button onclick="funcOne()">Klicken Sie auf funcOne</button>
<p id="one">Das ist funcOne</p>
<br>
<br>
<br>
<br>
<br>
<br>
<button onclick="funcTwo()">Klicken Sie auf funcTwo</button>
<p id="two">Das ist funcTwo</p>
<Skript>
    Funktion funcOne() {
        sei x = "";
        sei i = 0;
        für (i = 0; i < 10; i++) {
            wenn (i < 5) {
                brechen;
            }
            x = x + „Die Zahl ist“ + i + „<br>“;
        }
        document.getElementById("one").innerHTML = x;
    }

    Funktion funcTwo() {
        sei x = "";
        sei i = 0;
        für (i = 0; i < 10; i++) {
            if (i === 8) {
                weitermachen;
            }
            x = x + „Die Zahl ist“ + i + „<br>“;
        }
        document.getElementById("two").innerHTML = x;
    }
</script>

</body>
</html>

typeof, null und undefiniert

verwenden den Typeof-Operator, um den Datentyp der Variablen zu erkennen.

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>
<p id="one"></p>
<Skript>
    document.getElementById("one").innerHTML =
        Typ von „john“ + „<br>“ +
        Typ von 3.14 + "<br>" +
        typeof false + „<br>“ +
        Typ von [1, 2, 3, 4] + „<br>“ +
        typeof {Name: 'John', Alter: 34};

</script>

</body>
</html>

In JavaScript ist ein Array ein spezieller Objekttyp. Daher gibt typeof [1,2,3,4] ein Objekt zurück.

null bedeutet leer, also „nichts“. Bei Verwendung der Erkennungsart wird das Objekt zurückgegeben. Objekte können mit undefiniert gelöscht werden.

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>
<p>eins:</p>
<p id="one"></p>
<p>zwei:</p>
<p id="two"></p>

<Skript>
    var person = {Vorname: „Bill“, Nachname: „Gates“, Alter: 50};
    var person = null;
    document.getElementById("one").innerHTML = typeof person;
    Person = undefiniert
    document.getElementById("two").innerHTML = typeof person;
</script>

</body>
</html>

Konstruktoreigenschaft

Die Konstruktoreigenschaft gibt den Konstruktor aller JavaScript-Variablen zurück. Mit der Eigenschaft „Konstruktor“ können Sie prüfen, ob es sich bei dem Objekt um ein Array oder ein Datum (mit der Zeichenfolge „Date“) usw. handelt.

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>

<p>Das Konstruktorattribut gibt eine Variable oder einen Konstruktor zurück</p>
<p id="one">HRER</p>
<Skript>
    document.getElementById("one").innerHTML =
        "Hallo".constructor + "<br>" +
        3.14.constructor + "<br>" +
        false.constructor + „<br>“ +
        [1, 2, 3].constructor + „<br>“ +
        {name: "Hallo", Alter: 18}.constructor + "<br>" +
        new Date().constructor + "<br>" +
        Funktion () {
        }.constructor;
</script>

</body>
</html>

Typkonvertierung

JavaScript-Variablen können in neue Variablen oder andere Datentypen konvertiert werden:

automatisch von JavaScript selbst konvertiert,
indem JavaScript-Funktionen

<!DOCTYPE html>

verwendet werden

<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>

<p>Die Methode String() kann Zahlen in Zeichenfolgen umwandeln</p>
<p id="one">HIER</p>
<p>Die toString()-Methode kann Zahlen in Strings umwandeln</p>
<p id="two">HIER</p>
<Skript>
    sei x = 123;
    document.getElementById("one").innerHTML =
        String(x) + „<br>“ +
        String(123) + „<br>“ +
        String(100 + 23);
    document.getElementById("two").innerHTML =
        x.toString() + "<br>" +
        (123).toString() + "<br>" +
        (100 + 123,2).toString();
</script>

</body>
</html>

Unärer Operator+

Operator+ kann zum Konvertieren von Variablen in Zahlen verwendet werden:

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>

<P>Der Operator „typeof“ gibt den Variablen- oder Ausdruckstyp zurück</P>
<button onclick="myFuncOne()">KLICKEN SIE HIER EINS</button>
<p id="one">HIER</p>
<button onclick="myFuncTwo()">KLICKEN SIE HIER ZWEI</button>
<p id="two">HIER</p>
<Skript>
    Funktion myFuncOne() {
        sei y = „5“;
        sei x = +y;
        document.getElementById("one").innerHTML =
            Typ von y + „<br>“ + x + „<br>“ + Typ von x;
    }

    Funktion myFuncTwo() {
        let a = "Hallo";
        sei b = +a;
        document.getElementById("two").innerHTML =
            Typ von a + „<br>“ + b + „<br>“ + Typ von b;
    }

</script>
</body>
</html>

Konvertierung “

JavaScript-Typkonvertierung,
eines primitiven Werts	in eine Zahl	, Konvertierung einer Zeichenfolge,	Konvertierung in einen booleschen Wert,
false	0	„false“	false
true	1	„true“	true
0	0	„0“	false
1	1	„1“	true
„0	0	„0“	true
„000“	0	„000“	true
„1“	1	„1“	true
NaN	NaN	„NaN“	false
Infinity Infinity	„	Infinity“	true
-Infinity	-Infinity	„-Infinity“	true
„“	0	„“	false
„20“	20	„20 "	true
"Runoob"	NaN	"Runoob"	true
[ ]	0	""	true
[20]	20	"20"	true
[10,20]	NaN	"10,20"	true
["Runoob"]	NaN	"Runoob"	true
["Runoob" ,"Google"]	NaN	"Runoob,Google"	true
function(){}	NaN	"function(){}"	true
{ }	NaN	"[object Object]"	true
null	0	"null"	false
undefiniert	NaN	"undefiniert"	falsch

regulärer Ausdruck

Regulärer Ausdruck (englisch: Regular Expression, im Code oft als Regex, Regexp oder RE abgekürzt) verwendet eine einzelne Zeichenfolge, um eine Reihe von Zeichenfolgensuchmustern zu beschreiben und abzugleichen, die einer bestimmten Syntaxregel entsprechen.

search()

wird verwendet, um eine bestimmte Teilzeichenfolge in einer Zeichenfolge abzurufen oder eine Teilzeichenfolge abzurufen, die einem regulären Ausdruck entspricht, und gibt die Startposition der Teilzeichenfolge zurück.

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-kompatibler" content="IE=edge">
    <title>Titel</title>
</head>
<Körper>

<p>Zeichenfolge abrufen, Position abgleichen</p>

<button onclick="myFuncOne()">KLICKEN SIE HIER EINS</button>
<p id="one">HIER</p>

<button onclick="myFuncTwo()">KLICKEN SIE HIER ZWEI</button>
<p id="two">HIER</p>

<Skript>
    Funktion myFuncOne() {
        let str = "Hallo Welt!";
        document.getElementById("one").innerHTML = str.search(/World/i);
    }

    Funktion myFuncTwo() {
        let str = "Willkommen in China!";
        document.getElementById("two").innerHTML = str.search("China");
    }
</script>

</body>
</html>

replace()

wird verwendet, um einige Zeichen durch andere Zeichen in einer Zeichenfolge zu ersetzen oder eine Teilzeichenfolge zu ersetzen, die einem regulären Ausdruck entspricht.

<!DOCTYPE html>
<html lang="zh-CN">
<Kopf>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-äquiv = "x-ua-kompatible" content = "ie = edge">
    <title>Titel</title>
</head>
<Körper>

<p> regulärer Ausdruck Ersatz () Ersatz </p>

<button onclick = "myfuncone ()"> klicken Sie auf eine </button>
<p id = "eins"> Hallo, Java </p>

<button onclick = "myfunctwo ()"> Klicken Sie auf zwei </button>
<p id = "zwei"> Hallo, Java </p>

<Skript>
    Funktion myfuncone () {
        Sei str = document.getElementById ("eins"). Innerhtml;
        document.getElementById ("eins"). Innerhtml = Str.Replace (/java/i, "python");
    }

    Funktion myfunctwo () {
        let str = document.getElementById ("zwei"). Innerhtml;
        document.getElementById ("zwei"). Innerhtml = Str.Replace ("Java", "Javascipt");
    }
</script>

</body>
</html>

Regelmäßiges Expressionsmuster

regulärer Expressionsmodifikator-
Modifikator	Beschreibung
Ich	führt eine unempfindliche Übereinstimmung durch.
G	führt ein globales Match durch (findet alle Übereinstimmungen, anstatt nach dem ersten Spiel zu stoppen).
M	führt multi-line-Matching durch.

Charakters

Der reguläre Ausdruck Spezielle
Ausdrucksbeschreibung	des
[ABC]	findet ein Zeichen zwischen quadratischen Klammern.
[0-9]	findet eine beliebige Zahl von 0 bis 9.
(x \| y)	Findet alle Optionen, die durch \| getrennt sind.

Regelmäßiger Ausdruck Quantifizierer
Quantifizierer	Beschreibung
N+	Übereinstimmt jeder Zeichenfolge, die mindestens einen n enthält.
N*	übereinstimmt zu einer Zeichenfolge, die Null oder mehr N 'S enthält.
n	?

Test ()

wird verwendet, um festzustellen, ob eine Zeichenfolge mit einem bestimmten Muster übereinstimmt.

<!DOCTYPE html>
<html lang = "zh-cn">
<Kopf>
    <meta http-äquiv = "content-type" charset = "utf-8">
    <meta http-äquiv = "x-ua-kompatible" content = "ie = edge">
    <title>Titel</title>
</head>
<Körper>

<Skript>
    obj = neu regexp ("e");
    lass boolone = obj.test ("Hallo, das ist JavaScript");
    lass booltwo = obj.test ("Dies ist JavaScript");
    document.write (boolone + "<br>" + booltwo);
</script>

</body>
</html>

exec ()

wird verwendet, um Übereinstimmungen von regulären Ausdrücken in einer Zeichenfolge abzurufen. Wenn keine Übereinstimmung gefunden wird, ist der Rückgabewert null.

<!DOCTYPE html>
<html lang = "zh-cn">
<Kopf>
    <meta http-äquiv = "content-type" charset = "utf-8">
    <meta http-äquiv = "x-ua-kompatible" content = "ie = edge">
    <title>Titel</title>
</head>
<Körper>

<Skript>
    obj = new Regexp (/e/);
    resone = obj.exec ("Hallo, das ist JavaScript");
    restwo = obj.exec ("Dies ist JavaScript");
    /*No bedeutet null*/
    document.write (resone + "<br>" + restwo);
</script>

</body>
</html>

Fehler

-Ausnahmefehlertyp

Wenn die JavaScript -Engine JavaScript -Code ausführt, treten verschiedene Fehler auf.
Es kann sich um einen Syntaxfehler handeln, normalerweise ein Codierungsfehler oder ein Tippfehler vom Programmierer.
Könnte ein Rechtschreibfehler oder ein fehlendes Merkmal in der Sprache sein (möglicherweise aufgrund von Browserunterschieden).
Der Fehler kann auf eine falsche Ausgabe vom Server oder Benutzer zurückzuführen sein.
Natürlich könnte es auch auf viele andere unvorhersehbare Faktoren zurückzuführen sein.

Versuchen Sie ... Fangen Sie

die Anweisung an, ermöglicht es uns, einen Codeblock zu definieren, der während der Ausführung auf Fehler getestet wird. Mit der Catch -Anweisung können wir einen Codeblock definieren, der ausgeführt wird, wenn ein Fehler im Code -Block aus Try -Code auftritt.

<!DOCTYPE html>
<html lang = "zh-cn">
<Kopf>
    <meta http-äquiv = "content-type" charset = "utf-8">
    <meta http-äquiv = "x-ua-kompatible" content = "ie = edge">
    <title>Titel</title>
</head>
<Körper>

<Eingabe type = "button" value = "meldung anzeigen" onclick = "myfunc ()">
<Skript>
    sei txt = "";

    Funktion myfunc () {
        versuchen {
            alert111 ("Hallo, Welt!")
        }
        catch (err) {
            txt = "Es gibt hier einen Fehler  n  n";
            txt + = "Fehlerbeschreibung:" + err.message + " n  n";
            txt += "Klicken Sie auf OK, um  n  n" fortzusetzen;
            Alarm (TXT)
        }
    }
</script>

</body>
</html>

Die

Wurfanweisung

ermöglicht es uns, benutzerdefinierte Fehler zu erstellen. Der richtige technische Begriff ist: Erstellen oder Werfen einer Ausnahme. Wenn Sie Throw mit Try -and -Catch verwenden, können Sie den Programmfluss steuern und benutzerdefinierte Fehlermeldungen generieren.

<!DOCTYPE html>
<html lang = "zh-cn">
<Kopf>
    <meta http-äquiv = "content-type" charset = "utf-8">
    <meta http-äquiv = "x-ua-kompatible" content = "ie = edge">
    <title>Titel</title>
</head>
<Körper>

<p> Bitte geben Sie eine Nummer zwischen 5-10 </p> ein
<Label für = "eins"> </label> <input id = "ein" type = "text">
<button type = "button" "onclick =" myfunc () "> klicken Sie auf </button>
<p id = "message"> hier </p>

<Skript>
    Funktion myfunc () {
        Lassen Sie die Nachricht;
        sei x;
        message = document.getElementById ("message");
        message.innerhtml = "";
        x = document.getElementById ("eins"). Wert;
        versuchen {
            if (x === "")
                werfen "Wert ist leer";
            if (isnan (x))
                werfen "nicht eine Zahl";
            x = Nummer (x);
            if (x <5)
                "zu klein" werfen;
            if (x> 10)
                "zu groß" werfen;
        } Catch (Fehler) {
            message.innerhtml = "error" + fehler;
        }
    }
</script>

</body>
</html>

Funktionsaufruf

Es gibt vier Möglichkeiten, JavaScript -Funktionen aufzurufen. Im Allgemeinen zeigt dies in JavaScript auf das aktuelle Objekt, wenn die Funktion ausgeführt wird.

Rufen Sie 1 an: Rufen Sie als Funktion

eine

Funktion Myfunc (a, b) {auf {

auf.

    Rückkehr a * b;
}

myfunc

2);

    Rückkehr a * b;
}

Fenster.MyFunc

(1, 2

<html lang = "zh-cn">
<Kopf>
    <meta http-äquiv = "content-type" charset = "utf-8">
    <meta http-äquiv = "x-ua-kompatible" content = "ie = edge">
    <title>Titel</title>
</head>
<Körper>

<p> Funktionen, die als Methoden bezeichnet werden </p>
<p id = "eins"> hier </p>

<Skript>
    lass myObject = {
        FirstName: "Bill",
        LastName: "Gates",
        Vollname: function () {
            Gibt dies zurück.
        }
    };
    document.getElementById ("eins"). Innerhtml = myObject.fullname ();
</script>

</body>
</html>

Anruf 3: Rufen Sie den Konstruktor an, um die Funktion

<! docType html>

aufzurufen

<html lang = "zh-cn">
<Kopf>
    <meta http-äquiv = "content-type" charset = "utf-8">
    <meta http-äquiv = "x-ua-kompatible" content = "ie = edge">
    <title>Titel</title>
</head>
<Körper>

<p> In diesem Beispiel ist myfunc () der Konstruktor der Funktion </p>
<p id = "eins"> </p>
<Skript>
    Funktion myfunc (argone, argtwo) {
        this.name = argone;
        this.number = argtwo;
    }

    sei x = neuer myfunc ("Hallo", 123);
    document.getElementById ("eins"). Innerhtml = X.Name;
</script>

</body>
</html>

Anruf 4: Rufen Sie die Funktion als Funktionsmethode auf

<! docType html>
<html lang = "zh-cn">
<Kopf>
    <meta http-äquiv = "content-type" charset = "utf-8">
    <meta http-äquiv = "x-ua-kompatible" content = "ie = edge">
    <title>Titel</title>
</head>
<Körper>

<p> Funktionen als Funktionsmethoden </p> aufrufen
<p id = "eins"> hier </p>

<Skript>
    lass obj, array;

    Funktion myfunc (a, b) {
        Rückkehr a * b;
    }

    Array = [5, 6];
    obj = myfunc.apply (obj, array);
    document.getElementById ("eins"). Innerhtml = obj;
</script>

</body>
</html>

Verschluss

eingebettete Funktionen

In der Tat können in JavaScript alle Funktionen auf den Umfang ihrer oberen Ebene zugreifen. JavaScript unterstützt verschachtelte Funktionen, und verschachtelte Funktionen können auf Funktionsvariablen der oberen Ebene zugreifen. Die Inline -Funktion plus () kann auf die Zählervariable der übergeordneten Funktion zugreifen:

<! DocType html>
<html lang = "zh-cn">
<Kopf>
    <meta http-äquiv = "content-type" charset = "utf-8">
    <meta http-äquiv = "x-ua-kompatible" content = "ie = edge">
    <title>Titel</title>
</head>
<Körper>

<p> Inline -Funktionen </p>
<p id = "eins"> hier </p>

<Skript>
    document.getElementById ("eins"). Innerhtml = add ();

    Funktion add() {
        Zähle = 0;

        Funktion plus () {
            Zähler += 1;
        }

        Plus();
        Rückgabeschalter;
    }
</script>

</body>
</html>

Die Selbstverlebung der

Verschlussfunktion

wird als Bibao

<! docType html>

bezeichnet

<html lang = "zh-cn">
<Kopf>
    <meta http-äquiv = "content-type" charset = "utf-8">
    <meta http-äquiv = "x-ua-kompatible" content = "ie = edge">
    <title>Titel</title>
</head>
<Körper>

<p> Lokaler Zähler </p>
<button type = "button" "onclick =" myfunc () "> counter </button>
<p id = "eins"> hier </p>

<Skript>
    sei add = (function () {
        Zähle = 0;
        return function () {
            Rückgabezähler += 1;
        }
    })();

    Funktion myfunc () {
        document.getElementById ("eins"). Innerhtml = add ();
    }
</script>
</body>
</html>