Der Betrieb eines Computerprogramms erfordert den Betrieb von Werten wie der Zahl 3.14 oder dem Text „Hallo Welt“. In Programmiersprachen wird der Typ von Werten, der dargestellt und manipuliert werden kann, als Datentyp bezeichnet ( Typ). Die grundlegendste Programmiersprache. Die Funktion besteht darin, mehrere Datentypen zu hosten. Wenn ein Programm einen Wert für die zukünftige Verwendung speichern muss, weist es ihm eine Variable zu („speichert“ den Wert). Eine Variable ist ein symbolischer Name für einen Wert, und über den Namen kann eine Referenz auf den Wert abgerufen werden. Die Funktionsweise von Variablen ist ein grundlegendes Merkmal von Programmiersprachen. Dieses Kapitel bezieht sich auf den vorherigen Abschnitt, um den Inhalt dieses Kapitels besser zu verstehen, und wird später ausführlicher erläutert.
Javascript-Daten sind in zwei Kategorien unterteilt: primitiver Typ und Objekttyp
Die ursprünglichen Klassen in JavaScript umfassen Zahlen, Zeichenfolgen und boolesche Werte. In diesem Kapitel gibt es ein separates Kapitel, das Zahlen, Zeichenfolgen und booleschen Werten in JavaScript gewidmet ist. JavaScript verfügt außerdem über zwei spezielle Grundwerte: null (leer) und Undefiniert (undefiniert). Dabei handelt es sich nicht um Zahlen, Zeichenfolgen oder boolesche Werte. Sie repräsentieren jeweils ein einzigartiges Mitglied ihres eigenen speziellen Typs.
Javascript ist ein Objekt zusätzlich zu Zahlen, Zeichenfolgen, booleschen Werten, Null und undefiniert. Ein Objekt ist eine Sammlung von Eigenschaften. Jedes Attribut besteht aus einem „Name/Wert-Paar“ (der Wert kann ein primitiver Wert sein, z. B. eine Zahl, eine Zeichenfolge oder ein Objekt). Eines der spezielleren Objekte (globales Objekt wird in Miss 5 eingeführt und in Abschnitt 6 ausführlicher beschrieben)
Gewöhnliche JavaScript-Objekte sind unnötige Sammlungen „benannter Werte“. JavaScript definiert außerdem ein spezielles Objekt – ein Array, das eine geordnete Sammlung nummerierter Werte darstellt. JavaScript definiert eine spezielle Syntax für Arrays. Make-Arrays haben einige einzigartige Verhaltenseigenschaften, die sich von gewöhnlichen Objekten unterscheiden.
Javascript definiert auch eine spezielle Objektfunktion. Eine Funktion ist ein Objekt, dem ausführbarer Code zugeordnet ist. Die Funktion wird aufgerufen, um den ausführbaren Code auszuführen und das Ergebnis der Operation zurückzugeben. Funktionen verhalten sich wie Arrays anders als andere Objekte. JavaScript definiert eine spezielle Syntax für die Verwendung von Funktionen. Für Javascript-Funktionen. Am wichtigsten ist, dass es sich bei allen um echte Werte handelt und dass JavaScript sie wie gewöhnliche Objekte behandeln kann.
Wenn eine Funktion (mit dem neuen Operator) ein neues Objekt initialisiert, nennen wir es einen Konstruktor. Jeder Konstruktor definiert eine Klasse von Objekten – eine Sammlung von Objekten, die der Konstruktor initialisiert. Klassen können als Untertypen von Objekttypen betrachtet werden. Neben der Array-Klasse und der Funktionsklasse definiert JavaScript auch drei weitere nützliche Klassen. Date definiert ein Objekt, das ein Datum darstellt. Das reguläre Objekt (regExp) definiert einen regulären Ausdruck. Die Fehlerklasse definiert Objekte, die Laufzeitfehler und Syntaxfehler in JavaScript-Programmen darstellen. Sie können die erforderlichen Klassen definieren, indem Sie Ihren eigenen Konstruktor definieren.
Der JavaScript-Interpreter verfügt über einen eigenen Speicherverwaltungsmechanismus, der automatisch eine Speicherbereinigung durchführen kann. Dies bedeutet, dass das Programm Objekte bei Bedarf erstellen kann und sich der Programmierer keine Sorgen um die Zerstörung dieser Objekte und das Speicherrecycling machen muss. Wenn kein Verweis mehr auf ein Objekt vorhanden ist, weiß der Interpreter, dass das Objekt nicht mehr nützlich ist, und fordert automatisch die von ihm belegten Speicherressourcen zurück.
JavaScript ist eine objektorientierte Sprache. Vereinfacht gesagt bedeutet dies, dass wir keine globalen Funktionen definieren müssen, um verschiedene Arten von Werten zu verarbeiten. Um beispielsweise die Elemente in einem Array zu sortieren, ist eine Übergabe nicht erforderlich a Geben Sie die Funktion sort() ein, rufen Sie jedoch eine Methode sort()
auf
a.sort(); //Objektorientierte Version von sort(a)
Technisch gesehen können nur JavaScript-Objekte Methoden haben. Zahlen, Zeichenfolgen und boolesche Werte verfügen jedoch auch über eigene Methoden. In JavaScript sind nur null und undefiniert Werte, die keine Methoden haben können.
Javascript-Typen können in primitive Typen und Objekttypen sowie in Typen mit Methoden und Typen ohne Methoden unterteilt werden. Es kann auch in veränderliche und unveränderliche Typen unterteilt werden. Der Wert eines Variablentyps kann geändert werden. Objekte und Arrays sind Variablentypen: JavaScript-Programme können die Attributwerte von Objekten und die Werte von Array-Elementen ändern.
Zahlen, boolesche Werte, null und undefiniert sind unveränderliche Typen. Beispielsweise macht es an sich keinen Sinn, den Inhalt eines Arrays zu ändern. Eine Zeichenfolge kann man sich als eine Reihe von Zeichen vorstellen, und man kann sie sich als veränderbar vorstellen. In JavaScript sind Zeichenfolgen jedoch unveränderlich. Sie können an jeder Position in der Zeichenfolge auf den Text zugreifen, JavaScript bietet jedoch keine Methode zum Ändern des Textinhalts der Zeichenfolge.
Javascript kann die Datentypkonvertierung frei durchführen. Wenn beispielsweise eine Zahl verwendet wird, bei der das Programm eine Zeichenfolge erwartet, wandelt JavaScript die Zahl automatisch in eine Zeichenfolge um. Wenn ein nicht-boolescher Wert verwendet wird, wo ein boolescher Wert erwartet wird, wird JavaScript entsprechend konvertieren. Flexible Type-Grabbing- und Swapping-Regeln in JavaScript für „Gleichheit“
Variablen können nicht typisiert werden. Verwenden Sie das Schlüsselwort var, um Variablen zu deklarieren. JavaScript verwendet einen syntaktischen Bereich. Variablen, die in keiner Funktion deklariert sind, werden als globale Variablen bezeichnet, die überall im JavaScript-Programm sichtbar sind.
1. Zahlen
Im Gegensatz zu anderen Programmiersprachen unterscheidet JavaScript nicht zwischen Ganzzahlwerten und Gleitkommawerten. Numerische Werte in JavaScript werden durch Gleitkommawerte dargestellt. Wenn eine Zahl direkt in einem JavaScript-Programm erscheint, nennen wir sie ein numerisches Literal. JavaScript unterstützt numerische Literale in mehreren Formaten. (Hinweis: Das Hinzufügen eines Minuszeichens (-) direkt vor einer Zahl ergibt deren negativen Wert.) Das Minuszeichen ist jedoch der unäre Negationsoperator. ist nicht Teil der numerischen Literalgrammatik. )
i ganzzahlige direkte Menge
Verwenden Sie eine Array-Sequenz, um eine dezimale Ganzzahl in JavaScript darzustellen
JavaScript erkennt neben dezimalen Ganzzahlliteralen auch Werte, die auf dem Hexadezimalmechanismus (16) als Basis basieren. Der sogenannten Hexadezimalzahl wird „0X“ oder „0x“ vorangestellt, gefolgt von der direkten Menge der Hexadezimalzahlenfolge. Hexadezimale Werte bestehen aus Zahlen von 0–9 und Buchstaben zwischen a(A)–f(F). Die Buchstaben a-f stellen die Zahlen 10-15 dar. Das Folgende ist ein Beispiel für ein hexadezimales Ganzzahlliteral
0xff //15*16 15=255
0xCAFE911
Obwohl ECMAScript keine Oktalliterale unterstützt, können einige Implementierungen von JavaScript die Darstellung von Ganzzahlen in Oktalform (Basis 8) ermöglichen. Oktalliterale beginnen mit der Zahl 0, gefolgt von einer Ziffernfolge zwischen 0 und 7.
0377 // 3*64 7*8 7 =255 (dezimal)
Da einige Javascript-Implementierungen oktale Skalare unterstützen und andere nicht, ist es am besten, keine ganzzahligen Skalare mit dem Präfix 0 zu verwenden. Schließlich haben wir keine Möglichkeit zu wissen, ob die aktuelle Javascript-Implementierung oktales Parsen unterstützt. Im strikten Modus von ECMAScript 6 sind Oktalliterale ausdrücklich verboten.
ii. Gleitkomma-Literal
Gleitkomma-Literale können Dezimalstellen enthalten und verwenden die traditionelle Schreibweise reeller Zahlen. Eine reelle Zahl besteht aus einem ganzzahligen Teil, einem Dezimalpunkt und einem Dezimalteil.
Darüber hinaus können Sie auch die Exponentialschreibweise zur Darstellung von Gleitkommaliteralen verwenden. Das heißt, auf die reelle Zahl folgt der Buchstabe E oder e, gefolgt von einem positiven oder negativen Vorzeichen und dann einem ganzzahligen Exponenten. Der durch diese Zählmethode dargestellte Wert ist die Exponentialpotenz der vorherigen reellen Zahl multipliziert mit 10.
Zur Darstellung von
kann eine prägnantere Syntax verwendet werden
[Ziffern][.Ziffern][(E|e)[( |-)]Ziffern]
3.14
2345.455
.33333333333333333
6.02e23 //6.02*10 hoch 23
1,255454E-23 //1,255454*10 hoch minus 23
Arithmetische Operationen in iii.javascript
Javascript-Programme verwenden von der Sprache bereitgestellte arithmetische Operatoren, um numerische Operationen auszuführen. Zu diesen Operatoren gehören - * / und der Restoperator (Rest nach Division) %
Zusätzlich zu den Basisoperatoren unterstützt JavaScript auch komplexere arithmetische Operationen. Diese komplexe Operation wird durch Funktionen und Konstanten implementiert, die als Eigenschaften des Math-Objekts definiert sind.
Math.pow(2, 53) //=>9007199254740992 document.write(Math.pow(2,53) )
Math.round(.6) //=>1.0 Rundung
Math.ceil(.6) //=>1.0 aufrunden
Math.floor(.6) //=>0.0 abrunden
Math.abs(-5) //=>5 Finden Sie den Absolutwert
Math.max(x, y, z) //Gibt den Maximalwert zurück
Math.min(x, y, z) //Gib den Minimalwert zurück
Math.random() //Erzeuge eine Pseudozufallszahl größer als 0 und kleiner als 1
Math.PI //Pi
Math.E //e: Die Basis natürlicher Logarithmen
Math.sqrt(3) //Die Quadratwurzel von 3
Math.pow(3, 1 / 3) //Kubikwurzel von 3
Math.sin(0) //Trigonometrische Funktionen sowie Math.cos, Math.atan usw.
Math.log(10) //=>2.302585092994046 Der natürliche Logarithmus zur Basis 10
Math.log(512) / Math.LN2 //Der Logarithmus von 512 mit der Basis 2
Math.log(100) / Math.LN10 //Der Logarithmus von 100 mit der Basis 10
Math.exp(3) //Die dritte Potenz von e
Arithmetische Operationen in JavaScript melden keine Fehler bei Überlauf, Unterlauf oder Division durch Null. Das Ergebnis der numerischen Operation überschreitet jedoch die Obergrenze der Zahl, die in JavaScript ausgedrückt werden kann (Überlauf), und das Ergebnis ist ein spezieller unendlicher Wert (unendlich), der in JavaScript durch unendlich dargestellt wird. Wenn der Wert einer negativen Zahl den Bereich negativer Zahlen überschreitet, die JavaScript ausdrücken kann, ist das Ergebnis ebenfalls eine negative Unendlichkeit, die in JavaScript durch -Infinty dargestellt wird. Unendliche Werte verhalten sich wie erwartet: Addition, Subtraktion, Multiplikation und Division auf der Grundlage dieser Werte ergeben Unendlich (Vorzeichen bleiben erhalten)
Unterlauf ist eine Situation, die auftritt, wenn das Ergebnis einer Operation unendlich nahe bei Null liegt und kleiner als der Mindestwert ist, den JavaScript darstellen kann. Wenn eine negative Zahl unterläuft, gibt JavaScript einen speziellen Wert zurück, „negative Null“, der fast genau mit der normalen Null übereinstimmt. JavaScript-Programmierer verwenden selten eine negative Null.
Javascript definiert die globalen Variablen Infinaty und NaN vor, die zum Ausdrücken positiver Unendlichkeit und nicht numerischer Werte verwendet werden. In ECMAScipt3 können diese beiden Werte gelesen und geschrieben werden. ECMAScript5 behebt dieses Problem, indem es sie als schreibgeschützt definiert. Die vom Number-Objekt in ECMAScipt3 definierten Eigenschaftswerte sind ebenfalls schreibgeschützt. Hier einige Beispiele:
Infinity // Initialisiere eine Lese-/Schreibvariable auf unendlich
Number.POSITIVE_INFINITY //Gleicher Wert, schreibgeschützt
1 / 0 //Dies ist auch derselbe Wert
Number.MAX_VALUE 1 //Das Berechnungsergebnis ist immer noch Infinity
Number.NEGATIVE_INFINITY //Stellt negative Unendlichkeit dar
-Unendlich
-1/0
-Number.MAX_VALUE -1
Number.NaN //Gleicher Wert, aber schreibgeschützt
//Das Berechnungsergebnis ist immer noch NaN
Number.MIN_VALUE/2 //Unterlauf aufgetreten. Das Berechnungsergebnis ist 0
-Number.MIN_VALUE/2 //Negative Null
-1/Unendlich //Negative Null
-0
Der nicht-numerische Wert in JavaScript ist etwas Besonderes. Er ist nicht gleich dem menschlichen oder Wert, einschließlich sich selbst. Mit anderen Worten, es gibt keine Möglichkeit, anhand von x==NaN zu beurteilen, ob x NaN ist. Verwenden Sie stattdessen x! =x zur Beurteilung, genau dann, wenn x NaN ist, ist das Ergebnis des Ausdrucks wahr. Die Funktion isNaN() funktioniert ähnlich, wenn der Parameter NaN oder ein nicht numerischer Wert ist (z. B. eine Zeichenfolge und ein Objekt). dann Rückgabe true. Es gibt eine ähnliche Funktion isFinite() in JavaScript, die true zurückgibt, wenn der Parameter nicht NaN, Infinty oder -Infinity ist.
Der negative Nullwert ist ebenfalls etwas Besonderes. Er ist gleich positiver und negativer Null (sogar beurteilt mit dem strengen Gleichheitstest von JavaScript), was bedeutet, dass die beiden Werte fast identisch sind, außer als Teiler:
var null = 0;
var negz = -0;
Zero === negz //=>true Positive und negative Nullwerte sind gleich
1/null === 1/negz //false Positive Unendlichkeit und negative Unendlichkeit sind nicht dasselbe
iiii. Binäre Gleitkomma- und Rundungsfehler
Es gibt unzählige reelle Zahlen, aber JavaScript kann nur eine begrenzte Zahl in Form von Gleitkommazahlen darstellen (18.437.736.874.454.810.627, um genau zu sein, wenn reelle Zahlen in JavaScript verwendet werden). Oft handelt es sich nur um eine ungefähre Darstellung des wahren Wertes.
Javascript verwendet die IEEE-754-Gleitkommazahlendarstellung (wird von fast allen modernen Programmiersprachen verwendet). Dies ist eine binäre Darstellung, die Brüche wie 1/2 1/8 und 1/1024 genau darstellen kann. Leider sind die Brüche, die wir häufig verwenden, insbesondere in Finanzberechnungen, alle Dezimalbrüche 1/10, 1/100 usw. Die binäre Darstellung kann keine einfachen Zahlen wie 0,1 darstellen.
Zahlen in Javascript haben eine ausreichende Genauigkeit. Und kann nahe bei 0,1 liegen. Die Tatsache, dass die Zahl nicht genau ausgedrückt werden kann, bringt jedoch einige Probleme mit sich.
var x = .3 - .2;
var y = .2 - .1;
alarm(x == y) //=>false Die beiden Werte sind nicht gleich
x == .1 //=>false .3-.2 ist nicht gleich .1
y == .1 //=>true .2-.1 ist gleich 1
Aufgrund von Rundungsfehlern entspricht die ungefähre Differenz zwischen 0,3 und 0,2 nicht der ungefähren Differenz zwischen 0,2 und 0,1 (in einer realen Simulationsumgebung 0,3-0,2 = 0,099 999 999 999 999 98). Dieses Problem ist nicht gegeben ist einzigartig für JavaScript, aber es ist wichtig zu verstehen, dass es in jeder Programmiersprache vorkommt, die binäre Gleitkommazahlen verwendet. Beachten Sie auch, dass die Werte von x und y im obigen Code sehr nahe beieinander liegen und die endgültigen korrekten Werte sind. Dieses Berechnungsergebnis kann für die meisten Rechenaufgaben verwendet werden. Dieses Problem tritt nur auf, wenn zwei Werte auf Gleichheit verglichen werden.
Zukünftige Versionen von JavaScript unterstützen möglicherweise Dezimalzahlentypen, um dieses Problem zu vermeiden. Bis dahin bevorzugen Sie jedoch möglicherweise die Verwendung großer Ganzzahlen für wichtige Finanzberechnungen. Verwenden Sie beispielsweise ganzzahlige „Cents“ anstelle von dezimalen „Dollars“ für Operationen, die auf Währungseinheiten basieren.
iiii.Datum und Uhrzeit
Der Kern der JavaScript-Sprache enthält den Date()-Konstruktor, der ursprünglich Datums- und Zeitobjekte erstellt. Die Methoden dieser Datumsobjekte stellen eine einfache API für Datumsberechnungen dar. Datumsobjekte können keine grundlegenden Datentypen wie Zahlen sein.
var zhen = neues Datum(2011, 0, 1); //1. Januar 2011
var later = new Date(2011, 0, 1, 17, 10, 30); //Same day
var now = new Date(); //Aktuelles Datum und aktuelle Uhrzeit
var elapsed = now - zhen; //Datumssubtraktion. Berechnen Sie die Anzahl der Millisekunden im Intervall
later.getFullYear(); //=>2011
later.getMonth(); //=>0 Monat beginnend bei 0
later.getDate(); //=>1 Die Anzahl der Tage ab 1
later.getDay(); //=>5 Den Wochentag abrufen. 0 steht für Sonntag, 5 steht für Montag 1
later.getHours() //=>Ortszeit
later.getUTCHours() //Verwenden Sie UTC, um Stunden basierend auf der Zeitzone darzustellen.
2. Text
Eine Zeichenfolge ist eine unveränderliche geordnete Folge von 16-Bit-Werten. Jedes Zeichen stammt normalerweise aus dem Unicode-Zeichensatz. JavaScript repräsentiert Text durch den String-Typ. Die Länge einer Zeichenfolge ist die Anzahl der darin enthaltenen 16-Bit-Werte. Javascript-Strings (und Arrays davon) werden beginnend bei 0 indiziert. Die Länge einer leeren Zeichenfolge beträgt 0 und es gibt keinen „Zeichentyp“, der ein einzelnes Zeichen in JavaScript darstellt. Um einen 16-Bit-Wert darzustellen, weisen Sie ihn einfach einer String-Variablen zu. Die Länge dieser Zeichenfolge beträgt 1.
Zeichensatz, interner Code und Javascript-String
JavaScript verwendet den UTF-16-codierten Unicode-Zeichensatz. Eine JavaScript-Zeichenfolge ist eine Sequenz, die aus einem Satz unserialisierter 16-Bit-Werte besteht. Die am häufigsten verwendeten Unicode-Zeichen werden durch interne 16-Bit-Codes dargestellt und stellen ein einzelnes Zeichen in einer Zeichenfolge dar, die nicht als 16-Bit-Zeichen dargestellt werden kann. Sie folgen den UTF-16-Kodierungsregeln – verwenden Sie zwei 16-Bit-Zeichen werden als Sequenz dargestellt (auch „Ersatzpaar“ genannt). Dies bedeutet, dass ein JavaScript-String der Länge 2 (zwei 16-Bit-Werte) ein Unicode-Zeichen darstellen kann.
var p = „π“ ; //π wird durch den 16-Bit-internen Code 0x03c0
dargestellt
var e = "e"; //e wird durch einen 17-Bit-internen Code 0x1d452
dargestellt
p.length // =>1 p enthält einen 16-Bit-Wert
e.length // =>2 e enthält zwei Werte nach UTF-16-Codierung: „ud835udc52“
Die verschiedenen von JavaScript definierten String-Operationsmethoden arbeiten alle mit 16-Bit-Werten, nicht mit Zeichen, und Ersatzpaare werden nicht separat verarbeitet. Ebenso führt JavaScript keine standardisierte Verarbeitung von Zeichenfolgen durch. Es gibt keine Garantie dafür, dass die Zeichenfolge überhaupt im legalen UTF-16-Format vorliegt
i String-Literal
Ein Zeichenfolgenliteral in einem JavaScript-Programm ist eine in einfache Anführungszeichen oder doppelte Anführungszeichen eingeschlossene Zeichenfolge. Eine durch einfache Anführungszeichen begrenzte Zeichenfolge kann doppelte Anführungszeichen enthalten, und eine durch doppelte Anführungszeichen begrenzte Zeichenfolge kann auch einfache Anführungszeichen enthalten. Hier sind einige Beispiele für String-Literale.
"" //Leerer String, 0 Zeichen
'testen'
„3.14“
'name="myform"'
„Möchten Sie nicht O'Reilys Buch bevorzugen?“
In ECMAScript3 müssen String-Literale in eine Zeile geschrieben werden, aber in ECMAScript5 können String-Literale in mehrere Zeilen aufgeteilt werden, und jede Zeile muss mit einem Backslash (), einem Backslash und einem Zeilenabschlusszeichen enden. Keines davon ist das Inhalt von String-Literalen. Wenn Sie sie zusammen haben möchten, können Sie sie verwenden
Escape-Zeichen.
Es ist zu beachten, dass Sie bei der Verwendung von einfachen Anführungszeichen zum Trennen von Zeichenfolgen besonders auf Abkürzungen und alle Formatierungen im Englischen achten müssen. Das englische Apostroph und das einfache Anführungszeichen sind das gleiche Zeichen, daher müssen Sie Backslash () Escape verwenden.
ii Escape-Zeichen
In JavaScript-Strings hat der Backslash () einen besonderen Zweck. Das Hinzufügen eines Zeichens nach dem Backslash stellt beispielsweise nicht mehr deren wörtliche Bedeutung dar.
o //NUL-Zeichen
b //Rücktaste
t //Horizontales Tabulatorzeichen
n //Zeilenumbruchzeichen
v // Vertikales Tabulatorzeichen
F // Perspage-Zeichen
R
" //Doppelte Anführungszeichen
\ Backslash
xXX Latin-1-Zeichen, angegeben durch zwei Hexadezimalziffern
xXXXX Unicode-Zeichen, angegeben durch vier hexadezimale XXXX-Zeichen
Verwendung der III-Zeichenfolge
Eine der integrierten Funktionen von JavaScript ist die Zeichenfolgenverkettung. Die Verwendung des Operators mit Zeichenfolgen bedeutet eine Zeichenfolgenverkettung. Zum Beispiel
var msg = "hello" "world"; //Generiere die Zeichenfolge hallo Welt
Um die Länge einer Zeichenfolge zu bestimmen – die Anzahl der 16-Bit-Werte, die sie enthält, können Sie das Längenattribut verwenden, z. B. die Länge der Zeichenfolge s.
s.length
Zusätzlich zum Längenattribut stellen Strings auch viele Methoden bereit, die aufgerufen werden können.
var s = "hello,world";
s.charAt(0); //Das erste Zeichen von „h“
s.charAt(s.length - 1) //"d"Das letzte Zeichen
s.substring(1, 4) //"ell" 2-4 Zeichen
s.slice(1, 4) //ell Das Gleiche wie oben
s.slice(-3) // Die letzten 3 Zeichen
s.indexOf(l ")//Die Position, an der die beiden Zeichen l zum ersten Mal erscheinen
s.lastIndexOf("l") //10 Die Position, an der das Zeichen l zuletzt erschien
s.indexOf("l",3)//Nach Position 3 die Position, an der das l-Zeichen zum ersten Mal erscheint
s.split(",") //=> ["hello", "world"] ist in Teilzeichenfolgen unterteilt
s.replace("h","H")// =>"Hllo,world" Volltextzeichenersetzung
s.toUpperCase() //=>"HELLO,WORLD"
In JavaScript sind Zeichenfolgen festgelegt. Methoden wie replace() und toUpperCase() geben neue Zeichenfolgen zurück und die ursprünglichen Zeichen selbst ändern sich nicht.
In ECMAScript können Zeichen als schreibgeschützte Arrays behandelt werden. Zusätzlich zur Verwendung der charAt()-Methode können Sie auch eckige Klammern verwenden, um auf einzelne Zeichen in einer Zeichenfolge zuzugreifen. (16-Bit-Wert)
s = "Hallo Welt"
s[0] //=>"h"
s[s.length-1] //=>"d"
Foxfire hat die String-Indizierung schon vor langer Zeit auf diese Weise unterstützt, und die meisten modernen Browser (außer IE) sind in die Fußstapfen von Mozailla getreten und haben diese Funktion fertiggestellt, bevor ECMAScript Gestalt annahm
iiii Mustervergleich
Javascript definiert den RegExp()-Konstruktor, der zum Erstellen von Objekten verwendet wird, die den Textmusterabgleich darstellen. Diese Muster werden als „reguläre Ausdrücke“ (reguläre Ausdrücke) bezeichnet, die reguläre Ausdruckssyntax in JavaScript Caiyang Perl. Sowohl die String- als auch die RegExp-Objekte definieren Funktionen für den Mustervergleich sowie die Suche und Ersetzung mithilfe regulärer Ausdrücke.
Das RegExp-Objekt ist kein grundlegender Datentyp in der Sprache, sondern lediglich ein spezielles Objekt mit einer praktischen API. Die Syntax regulärer Ausdrücke ist komplex und die API ist umfangreich. Es wird in Kapitel 10 ausführlich vorgestellt. RegExp ist ein leistungsstarkes und häufig verwendetes Textverarbeitungstool. Dies ist nur ein Überblick.
Obwohl RegExp kein grundlegender Datentyp in der Sprache ist, haben sie dennoch eine direkte Schreibweise und können direkt in JavaScript verwendet werden. Der Text zwischen zwei Schrägstrichen bildet das Literal eines regulären Ausdrucks. Dem zweiten Schrägstrich können auch ein oder mehrere Buchstaben folgen. Wird verwendet, um die Bedeutung übereinstimmender Muster zu ändern. Zum Beispiel:
/^HTML/ // Zeichenfolgen abgleichen, die mit HTML
beginnen
/[1-9][0-9]*/ // Entspricht einer Zahl ungleich Null, gefolgt von einer beliebigen Anzahl von Zahlen
/bjavascriptb/i/ // Passen Sie das Wort „Javascript“ an und ignorieren Sie die Groß-/Kleinschreibung
Das RegExp-Objekt definiert viele nützliche Methoden, und Zeichenfolgen verfügen auch über Methoden, die RegExp-Parameter akzeptieren können. Zum Beispiel:
var text = "testing:1,2,3"; //Textbeispiel
var pattern = /d /g / //Alle Instanzen abgleichen, die eine oder mehrere Ziffern enthalten
pattern.test(text) // =>true: Übereinstimmung erfolgreich
text.search(pattern) //=>9: Die Position des ersten erfolgreichen Treffers
text.match(pattern) //=> Alle Übereinstimmungen bilden ein Array
text.repeat(pattern,"#"); //=>"testing:#,#,#"
text.split(/D /); //=>["","1","2","3"]: Verwenden Sie nicht numerische Zeichen, um die Zeichenfolge
abzufangen
3.Boolescher Wert
Boolescher Wert bezieht sich auf wahr oder falsch, ein oder aus. Dieser Typ hat nur zwei Werte, die reservierten Wörter wahr oder falsch
Die Ergebnisse von Vergleichsanweisungen in JavaScript sind normalerweise boolesche Werte. Zum Beispiel
a==4
Dieser Code wird verwendet, um zu erkennen, ob der Wert der Variablen a gleich 4 ist. Wenn er gleich ist, ist der Wert wahr, wenn nicht, ist der Wert falsch
Boolesche Werte werden normalerweise in JavaScript-Steueranweisungen verwendet, z. B. in if/else-Anweisungen in JavaScript. Wenn der boolesche Wert wahr ist, führen Sie den ersten Teil der Logik aus, und wenn er falsch ist, führen Sie einen weiteren Teil des Codes aus. wie zum Beispiel
Wenn (a == 4)
b = b 1;
sonst
a = a 1;
Jeder JavaScript-Wert kann in einen booleschen Wert umgewandelt werden. Die folgenden Werte werden in false umgewandelt
undefiniert
null
0
-0
NaN
""//Leere Zeichenfolge
Alle anderen Werte, einschließlich aller Objekte (Arrays), werden in „true“, „false“ und die oben genannten 6 Werte, die in „false“ konvertiert werden können, werden manchmal als „falsche Werte“ bezeichnet. Wenn JavaScript die Verwendung eines booleschen Werts erwartet, Der falsche Wert wird als falsch behandelt, der wahre Wert wird als wahr behandelt
Schauen wir uns ein Beispiel an. Wenn wir hinzufügen, dass die Variable o ein Objekt oder Null ist, können Sie eine if-Anweisung verwenden, um zu erkennen, ob o ein Nicht-Null-Wert ist.
if(o!==null)...
Der Ungleichheitsoperator „!==" vergleicht o und null und das Ergebnis ist wahr oder falsch. Sie können die Vergleichsanweisung hier zunächst ignorieren. Null ist ein falscher Wert und das Objekt ist ein wahrer Wert.
wenn(o)...
Im ersten Fall wird der Code nach if ausgeführt, solange o nicht null ist. Im zweiten Fall sind die Einschränkungen nicht so streng. Dieses if wird nur ausgeführt, wenn o nicht falsch ist oder einen falschen Wert hat (z. B. null oder unfined).
Boolean enthält die Methode toString(), sodass Sie diese Methode verwenden können, um einen String in „true“ oder „false“ umzuwandeln, aber sie enthält keine anderen nützlichen Methoden. Zusätzlich zu dieser unwichtigen API gibt es drei wichtige Einsen Boolescher Operator.
&&-Operator, ||.-Operator und unärer Operator „!“ führen eine boolesche NOT-Operation (NOT) aus
Wenn ((x == 0 && y == 0) || !(z == 0)) {
// x und y sind beide Null oder z ist ungleich Null
}
4.null und undefiniert
Null ist ein Schlüsselwort in der JavaScript-Sprache. Es stellt einen speziellen Wert „Nullwert“ dar. Für null wird die typeof()-Operation ausgeführt und ein Objekt zurückgegeben. Mit anderen Worten, null kann als spezieller Objektwert betrachtet werden. was „Nicht-Objekt“ bedeutet. Tatsächlich wird null jedoch normalerweise als das einzige Mitglied seines freien Typs betrachtet. Es kann Zahlen, Zeichenfolgen und Objekte darstellen, die „wertlos“ sind. Die meisten Programmiersprachen enthalten Nullen wie JavaScript, und Sie sind möglicherweise mit Null oder Null vertraut.
Javascript hat auch einen zweiten Wert, der die freie Stelle des Werts angibt. Wird zur Darstellung tieferer „Nullwerte“ verwendet. Es ist ein Wert einer Variablen. Zeigt an, dass die Variable nicht initialisiert ist. Wenn Sie den Wert einer Objekteigenschaft oder eines Array-Elements abfragen und undefiniert zurückgeben möchten, bedeutet dies, dass die Eigenschaft oder das Element nicht vorhanden ist. undefiniert ist eine vordefinierte globale Variable (sie unterscheidet sich von null, es ist kein Schlüsselwort) und ihr Wert ist undefiniert. Wenn typeof zum Testen auf einen undefinierten Typ verwendet wird, wird „undefiniert“ zurückgegeben, was darauf hinweist, dass dieser Wert das einzige Mitglied dieses Typs ist.
Obwohl null und undefiniert unterschiedlich sind, stellen sie beide eine „Wertlücke“ dar und sind oft austauschbar. Der Gleichheitsoperator „==" betrachtet die beiden als gleich (zur Unterscheidung muss der strikte Gleichheitsoperator „===" verwendet werden). Wenn erwartet wird, dass ein Wert vom Typ Boolean ist, ist sein Wert falsch. Ähnlich wie false. Sowohl null als auch undefiniert enthalten keine Eigenschaften oder Methoden. Tatsächlich führt die Verwendung von „.“ und „[]“ zum Zugriff auf Mitglieder oder Methoden dieser beiden Werte zu einem Typfehler.
Sie denken vielleicht, dass undefiniert unerwartete oder fehlerähnliche Wertfreistellen auf Systemebene darstellt und null normale oder erwartete Wertfreistellen auf Programmebene darstellt, wenn Sie diese Variablen oder Eigenschaften kopieren oder an Funktionen übergeben möchten Parameter, null ist die beste Wahl.
5. Globales Objekt
In den vorherigen Abschnitten wurden JavaScript-Elementtypen und Grundwerte besprochen. Objekttypen – Objekte, Arrays und Funktionen/Aber es gibt eine sehr wichtige Klasse von Objekten, die jetzt klargestellt werden muss: globale Objekte
Globale Objekte spielen in JavaScript eine wichtige Rolle. Eigenschaften globaler Objekte sind global definierte Symbole. JavaScript-Programme können direkt verwendet werden. Wenn der JavaScript-Interpreter startet, erstellt er ein neues globales Objekt und weist ihm einen definierten Satz anfänglicher Eigenschaften zu.
Globale Eigenschaften wie undefinierte Infinty und NaN
Globale Funktionen wie isNaN(), parseInt() und eval()
Konstruktoren wie Date(), RegExp(), String(), Object() und Array()
Globale Objekte wie Math und JSON
Anfangseigenschaften globaler Objekte sind keine reservierten Wörter, sollten aber als solche behandelt werden.
Auf der obersten Ebene des Codes – Javascript-Code, der sich nicht in einer Funktion befindet – kann über das Schlüsselwort Javascript auf das globale Objekt verwiesen werden.
var global = this; //Definieren Sie eine globale Variable, die auf das globale Objekt verweist.
In clientseitigem JavaScript fungiert das Fensterobjekt als globales Objekt. Es kann durch einen Verweis auf das globale Fenster ersetzt werden, das die globalen Kerneigenschaften definiert. Es definiert aber auch einige andere globale Eigenschaften für Webbrowser und interaktives JavaScript.
Bei der ersten Erstellung definiert das globale Objekt alle vordefinierten globalen Werte in JavaScript. Dieses spezielle Objekt enthält auch globale Werte, die für das Programm definiert sind. Wenn der Code eine globale Variable deklariert. Diese globale Variable ist eine Eigenschaft des globalen Objekts.
6. Verpackungsobjekt
Ein JavaScript-Objekt ist ein zusammengesetzter Wert: Es ist eine Sammlung von Eigenschaften oder benannten Werten. Der Attributwert wird über „.“ referenziert. Wenn der Attributwert eine Funktion ist, handelt es sich um eine Methode, und die Methode im Objekt o wird über o.m() versendet.
Wir sehen, dass Strings auch Eigenschaften und Methoden haben.
var s="Hallo Welt";
var word = s.substring(s.indexOf("") 1,s.length);//Verwenden Sie die Attribute des Strings.
document.write(word) //"ello world"
Da eine Zeichenfolge kein Objekt ist, warum hat sie dann Attribute? Solange auf die Eigenschaften von Strings verwiesen wird, wandelt JavaScript den Wert des Strings in ein Objekt um, indem es neue String(s) aufruft. Dieses Objekt erbt die Methoden von String. und wird zur Verarbeitung von Eigenschaftsverweisen verwendet. Sobald auf das neue Attribut verwiesen wird. Sobald die Referenz beendet ist, wird das neu erstellte Objekt zerstört. (Dieses temporäre Objekt wird nicht tatsächlich erstellt oder zerstört, der Prozess sieht jedoch so aus.)
Wie Zeichenfolgen verfügen auch Zahlen und boolesche Werte über eigene Methoden, die über die Konstruktoren Number() und Boolean() ein temporäres Objekt erstellen. Die Aufrufe dieser Methoden kommen alle von diesem temporären Objekt. (null und undefiniert sind keine umschlossenen Objekte und der Zugriff auf ihre Eigenschaften führt zu einem Typfehler)
Sehen Sie sich die folgenden Codes an und denken Sie über ihren Ausführungsprozess nach
var s = "test";
s.len = 4; //Setze ein Attribut dafür
var t = s.len //Dieses Attribut finden
Wenn dieser Code ausgeführt wird, ist der Wert von t undefiniert. Die zweite Codezeile erstellt ein temporäres Zeichenfolgenobjekt und gibt den Wert von len als 4 an, dann zerstört die dritte Codezeile das Original (unverändert). ) ) erstellt ein neues String-Objekt und versucht, die len-Eigenschaft zu lesen.
Dieses Attribut existiert natürlich nicht, was darauf hinweist, dass das Ergebnis undefiniert ist. Dieser Code zeigt, dass es sich beim Lesen der Attributwerte (oder Methoden) von Zeichenfolgen, Arrays und booleschen Werten wie ein Objekt verhält, aber wenn Sie Versuchen Sie, seinem Attribut einen Wert zuzuweisen. Dieser Vorgang wird ignoriert; die Änderung erfolgt nur am temporären Objekt. Dieses temporäre Objekt wird nicht beibehalten.
Es ist zu beachten, dass Sie Wrapper-Objekte explizit über die Konstruktoren String(), Number() und Boolean() erstellen können:
var s = "test",
n = 1,
b = true;
var S = neue Zeichenfolge(n);
var N = neue Zahl(n);
var B = new Boolean(b);
Javascript konvertiert den Wrapper bei Bedarf in einen primitiven Wert, daher verhält sich das Objekt S N B im obigen Code oft – aber nicht immer – genauso wie s n b. Der „==“-Gleichheitsoperator konvertiert den ursprünglichen Wert und verpackt ihn Objekte werden als gleich behandelt.
Aber der Operator „===“ behandelt sie als ungleich, und der Operator „typeof“ kann den Unterschied zwischen dem ursprünglichen Wert und dem Objekt erkennen, das er umschließt.
7. Unveränderliche Grundwerte und veränderliche Objektreferenzen.
Die primitiven Werte von Javascript (undefinierte boolesche Nullwerte, Zahlen und Zeichenfolgen) unterscheiden sich grundlegend von Objekten (einschließlich Arrays und Funktionen). Keine Methode kann einen primitiven Wert ändern (oder mutieren). Dies gilt offensichtlich für Zahlen und boolesche Werte – das Ändern des Werts einer Zahl selbst macht keinen Sinn, aber für Zeichenfolgen, die wie Zeichenarrays aussehen, ist es weniger offensichtlich. Wir gehen davon aus, dass die Zeichen in der Zeichenfolge durch den angegebenen Index geändert werden können. Tatsächlich verbietet JavaScript dies. Alle Methoden in string scheinen einen geänderten String zurückzugeben, geben aber tatsächlich einen neuen String zurück.
var s = "Hallo Welt";
s.toUpperCase(); //Gibt „HELLO WORLD“ zurück und ändert den Wert von s nicht
s //=> „Hallo Welt“ Die ursprüngliche Zeichenfolge hat sich nicht geändert
Der Vergleich der Originalwerte ist ein Wertevergleich. Sie sind nur dann gleich, wenn ihre Werte gleich sind. Das klingt für Zahlen, boolesche Werte, null und undefiniert etwas schwierig, und es gibt keine andere Möglichkeit, sie zu vergleichen. Auch hier ist es bei Zeichenfolgen weniger offensichtlich; wenn Sie zwei separate Zeichenfolgen vergleichen, betrachtet JavaScript sie genau dann als gleich, wenn ihre Längen und Zeichen an jedem Index gleich sind.
var o = {x:1} //Definiere ein Objekt
o.x = 2 //Ändern Sie das Objekt, indem Sie seine Eigenschaften ändern
o.y = 3 //Ändern Sie dieses Objekt erneut und fügen Sie ihm ein neues Attribut hinzu
var a =[1,2,3] //Arrays können auch geändert werden
a[0]=0; //Ein Element im Array ändern
a[3]=4; Füge ein neues Element zum Array hinzu
Der Vergleich von Objekten ist kein Vergleich von Werten: Selbst wenn zwei Objekte dieselben Attribute und dieselben Werte enthalten, sind sie nicht gleich, und zwei Arrays mit genau gleichen Indexelementen sind nicht gleich
var o ={x:1}, p={x:1}//Zwei Objekte mit den gleichen Attributen
o === p ;//=>false Zwei separate Objekte sind niemals gleich ( o == p ; =>false)
var a =[],b=[] //Zwei separate leere Arrays
a === b; //=>false Zwei separate Arrays sind niemals gleich
Wir nennen Objekte normalerweise Referenztypen, um sie von den Grundtypen von JavaScript zu unterscheiden. Gemäß der Terminologie sind Objekte Referenzen und Vergleiche von Objekten sind Vergleiche von Referenzen; sie sind nur dann gleich, wenn sie dasselbe Basisobjekt verwenden.
var a = []; //Definieren Sie eine Variable a
, die auf ein leeres Array verweist
var b = a; //Variable b bezieht sich auf dasselbe Array
b[0] = 1;
a[0] //=>1 Variable a wird ebenfalls geändert
a === b //=>true a und b beziehen sich auf dasselbe Array, sind also gleich.
Genau wie bei dem Code, den Sie gerade oben gesehen haben, handelt es sich bei der Zuweisung eines Objekts (oder Arrays) zu einer Variablen lediglich um die Zuweisung eines Referenzwerts: Das Objekt selbst wird nicht einmal kopiert.
Wenn Sie eine Kopie eines Objekts oder Arrays erhalten möchten, müssen Sie jede Eigenschaft des Objekts oder jedes Element des Arrays explizit kopieren. Das folgende Beispiel vervollständigt die Kopie des Arrays durch eine Schleife.
var a = ['a', 'b', 'c']; //zu kopierendes Array
var b = [] //In das leere Array des Ziels kopieren
for (var i = 0; i < a.length; i ) { //Durchlaufe jedes Element in a[]
b[i] = a[i] //Kopiere das Element nach b.
}
Wenn wir zwei Personen oder Arrays vergleichen möchten, müssen sie auch ihre Attribute oder Elemente vergleichen. Der folgende Code definiert eine Funktion, die ein Array vergleicht.
Funktion equalArrays(a, b) {
If (a.length != b.length) return false; //Zwei Arrays mit unterschiedlichen Längen sind nicht gleich
for (var i = 0; i < a.length; i) // Schleife durch alle Elemente
If (a[i] !== b[i]) return false; //Wenn irgendwelche Elemente nicht gleich sind, sind die Arrays nicht gleich
return true; // Ansonsten sind sie gleich
}
8. Typkonvertierung
Werttypen in JavaScript sind sehr flexibel. Wir haben dies bereits bei booleschen Werten gesehen: Wenn JavaScript einen booleschen Wert erwartet, können Sie jeden Werttyp angeben. JavaScript konvertiert den Typ selbst nach Bedarf. Einige Werte (Wahrheitswerte) sind wahr, andere Werte (falsche Werte) werden in falsch umgewandelt. Das Gleiche gilt für andere Typen. Wenn JavaScript einen String erwartet, wandelt es den angegebenen Wert in einen String um. Wenn JavaScript ein Array erwartet, wandelt es den angegebenen Wert in eine Zahl um (und gibt NaN zurück, wenn das Konvertierungsergebnis bedeutungslos ist), einige Beispiele sind wie folgt:
10 „object“ //=> „10object“;
"7" * "4" // =>28 Beide Strings werden in Zahlen umgewandelt
var n = 1 - "x" // =>NaN-String x kann nicht in eine Zahl umgewandelt werden
&
In der folgenden Tabelle wird erläutert, wie Sie die Typkonvertierung in JavaScript durchführen. Fett hebt Typen hervor, die Sie überraschen könnten. Leere Zellen stellen Konvertierungen dar, die unnötig sind und nicht durchgeführt werden.
| Wert |
In String konvertieren |
Nummer |
Boolescher Wert |
Objekt |
undefiniert
null |
"undefiniert"
„null“ |
NaN
0 |
falsch
falsch |
löst TypeError aus
löst TypeError | aus
true
false |
"ture"
"false" |
1
0 |
|
new Boolean(true)
new Boolean(false) |
""（空字符串）
"1.2"(非空，数字)
"one"(非空，非数字) |
|
0
1.2
NaN |
false
wahr
wahr |
new String("")
neuer String("1.2")
neuer String("one") |
0
-0
NaN
Unendlich
-Unendlich
1(unendlich, ungleich Null) |
"0"
„0“
„NaN“
„Unendlich“
„-Infinity“ „1“ |
|
falsch
falsch
falsch
wahr
wahr
wahr |
neue Nummer(0);
neue Zahl(-0);
neue Zahl (NaN)
neue Zahl (Unendlich)
neue Zahl(-Unendlich)
neue Nummer(1) |
{}(beliebiges Objekt)
[](beliebiges Array)
[9](1 numerisches Element)
['a'](anderes Array)
Funktion(){}(fonction arbitraire) |
Référez-vous à la troisième section de cette section
""
"9"
Utilisez la méthode join()
Veuillez vous référer à la troisième section de cette section |
Référez-vous à la troisième section de cette section
0
9
NaN
NaN |
vrai
vrai
vrai
vrai
vrai
|
|
La conversion de la valeur originale en valeur originale mentionnée dans le tableau ci-dessus est relativement simple. Nous avons déjà discuté de la conversion en valeur booléenne dans la troisième section de cet article. La conversion de toutes les valeurs primitives en chaînes est également clairement définie. La conversion en nombres est plus subtile. Les chaînes représentées sous forme de nombres peuvent être converties directement en nombres, les espaces étant autorisés au début et à la fin. Cependant, tous les caractères non nuls au début et à la fin ne seront pas considérés comme faisant partie du nombre, ce qui fera que le résultat de la chaîne sera NaN. Certaines conversions de nombres semblent étranges : vrai est converti en 1, faux et la chaîne vide "" est convertie en 0.
La conversion des valeurs primitives en objets est également très simple, valeurs primitives
