JavaScript Core Leseerfahrung Typen, Werte und Variablen

Der Betrieb eines Computerprogramms erfordert Betriebswerte wie die Nummer 3.14 oder den Text "Hello World". In Programmiersprachen wird der Werttyp, der dargestellt und betrieben werden kann, als Datentyp bezeichnet. Die grundlegendste Funktion von Programmiersprachen besteht darin, mehrere Datentypen zu hosten. Wenn das Programm den Wert für die zukünftige Nutzung beibehalten muss, wird es ("den Wert" in eine Variable "speichern". Eine Variable ist ein symbolischer Name eines Wertes, und ein Hinweis auf einen Wert kann mit dem Namen erhalten werden. Der Arbeitsmechanismus von Variablen ist ein grundlegendes Merkmal von Programmiersprachen. In diesem Kapitel wird sich auf den vorherigen Abschnitt beziehen, um den Inhalt dieses Kapitels 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 enthalten Zahlen, Zeichenfolgen und Boolesche Werte. In diesem Kapitel wird ein separates Kapitel über die Zahlen, Zeichenfolgen und Booleschen Werte von JavaScript über die JavaScript -Werte informiert. JavaScript hat auch zwei spezielle Rohwerte, null (leer) und undefinierte (undefinierte), sie sind keine Zahlen, Zeichenfolgen oder Booleschen Werte. Sie repräsentieren die einzigen Mitglieder ihrer jeweiligen besonderen Typen.

JavaScript ist ein Objekt neben Zahlen, Strings, Booleschen Werten, Null und undefiniert. Ein Objekt ist eine Sammlung von Eigenschaften. Jedes Attribut besteht aus einem "Namen/Wertpaar" (der Wert kann ein primitiver Wert sein, z. B. eine Zahl, eine Zeichenfolge oder ein Objekt). Eines der besonderen Objekte (globales Objekt wird in Miss Fifth eingeführt, und der sechste Abschnitt wird ausführlicher beschrieben)

Normale JavaScript-Objekte sind No-notwendige Sammlungen von "benannten Werten". JavaScript definiert auch ein spezielles Objekt - ein Array, das einen geordneten Satz nummerierter Werte darstellt. JavaScript definiert eine dedizierte Syntax für Arrays. Machen Sie Arrays einige einzigartige Verhaltenseigenschaften, die sich von gewöhnlichen Objekten unterscheiden.

JavaScript definiert auch eine spezielle Objektfunktion. Eine Funktion ist ein Objekt mit ausführbarer Code, mit dem sie assoziieren möchte. Es führt den Code aus, indem Sie die Funktion aufrufen und das Ergebnis des Vorgangs zurückgeben. Wie Arrays unterscheiden sich Funktionsverhaltensmerkmale von anderen Objekten. JavaScript definiert eine spezielle Syntax für die Verwendung von Funktionen. Für JavaScript -Funktionen. Am wichtigsten ist, dass sie alle wahre Werte sind, und JavaScript kann verwendet werden, um sie als gewöhnliche Objekte zu behandeln.

Wenn eine Funktion ein neues Objekt initialisiert (mit dem neuen Bediener), nennen wir es einen Konstruktor. Jeder Konstruktor definiert eine Klassenobjekt-A-Sammlung, die aus Konstruktorinitialisierungsobjekten besteht. Klassen können als Subtyp von Objekttypen angesehen werden. Neben Array -Klassen und Funktionsklassen definiert JavaScript auch drei andere verwendete Klassen. Ein Datum definiert ein Objekt, das ein Datum darstellt. Regexp definiert das Objekt regulärer Ausdrücke. Die Fehlerklasse definiert die Zeile, die den Runtime -Fehler und das Syntax -Fehlerobjekt in einem JavaScript -Programm darstellt. Sie können die erforderliche Klasse definieren, indem Sie Ihren eigenen Konstruktor definieren.

Der JavaScript -Dolmetscher verfügt über einen eigenen Speicherverwaltungsmechanismus, der automatisch Müllsammlung von Speicher erfasst kann. Dies bedeutet, dass das Programm Objekte bei Bedarf erstellen kann und Programmierer sich keine Sorgen um die Zerstörung dieser Objekte und das Speicherrecycling machen müssen. Wenn kein Bezugspunkt auf ein Objekt zeigt, weiß der Dolmetscher, dass das Objekt nutzlos ist und die von ihm eingestellten Speicherressourcen automatisch recycelt.

JavaScript ist eine objektorientierte Sprache. Nicht genau genommen, dies bedeutet, dass wir keine globalen Definitionsfunktionen verwenden, um verschiedene Arten von Werten zu betreiben. Der Datentyp selbst kann Methoden zur Verwendung von Werten definieren. Um beispielsweise Elemente in Array A zu sortieren, müssen keine in Sort () -Funktion übergeben, sondern eine Methode sortiert () übertragen werden ()

a.sort (); // sortieren (a) objektorientierte Version

Technisch gesehen können nur JavaScript -Objekte Methoden haben. Zahlen, Zeichenfolgen und Boolesche Werte haben jedoch auch ihre eigenen Methoden. In JavaScript sind nur Null und undefinierte Werte, die keine Methoden haben können.

Die Arten von JavaScript können in primitive Typen und Objekttypen unterteilt und in Typen unterteilt werden, die Methoden und Typen haben können, die keine Methoden haben können. Es kann auch in veränderliche und unveränderliche Typen unterteilt werden. Die Werte von veränderlichen Typen können geändert werden, und Objekte und Arrays gehören zu veränderlichen Typen: JavaScript -Programme können den Wert des Attributwerts eines Objekts und den Wert von Array -Elementen ändern.

Zahlen, Booleans, Nulls und undefinierte sind unveränderliche Typen. Beispielsweise macht das Ändern des Inhalts eines Arrays selbst keinen Sinn. Eine Zeichenfolge kann als eine Reihe von Zeichen angesehen werden, und Sie können denken, dass sie geändert werden kann. In JavaScript sind Strings jedoch unveränderlich. Sie können in einer beliebigen Position einer Zeichenfolge auf Text zugreifen, JavaScript bietet jedoch keine Möglichkeit, den Textinhalt der Zeichenfolge ständig zu ändern.

JavaScript kann die Datentypkonvertierung frei durchführen. Wenn beispielsweise eine Nummer verwendet wird, wobei das Programm erwartet, eine Zeichenfolge zu verwenden, konvertiert JavaScript die Nummer automatisch in eine Zeichenfolge. Wenn Sie erwarten, dass Sie einen nicht-boolischen Wert verwenden, bei dem der Boolesche Wert verwendet wird, konvertiert JavaScript auch entsprechend. In JavaScript werden die Regeln für "Gleichstellung der Beurteilung" verwendet, um "Gleichheit" (Gleichheit) zu beurteilen

JavaScript -Variablen sind nicht typisch. Variablen können Personen und Typen zugeordnet werden. Variablen können mit dem Schlüsselwort var deklariert werden. JavaScript übernimmt den Syntaxumfang. Variablen, die in keiner Funktion deklariert sind, werden als globale Variablen bezeichnet. Sie sind überall im Programm von JavaScript sichtbar.

1. Zahlen

Im Gegensatz zu anderen Programmiersprachen unterscheidet JavaScript nicht zwischen ganzzahligen Werten und schwimmenden Punktwerten. Alle Werte in JavaScript werden durch schwimmende Punktwerte ausgedrückt. Wenn eine Zahl direkt in einem JavaScript -Programm erscheint, sind wir ein numerisches Literal, und JavaScript unterstützt numerische direkte Mengen in mehreren Formaten. (Hinweis: Hinzufügen eines negativen Vorzeichens (-) direkt, bevor eine beliebige Zahl ihre negativen Werte erhalten kann.) Das negative Vorzeichen ist jedoch ein Einweg-Inverse-Operator. , keine Komponente der Grammatik der direkten numerischen Mengen. )

I Ganzzahltyp Direct Menge

Eine Dezimalbezahlung wird durch eine Array -Sequenz in JavaScript dargestellt

Zusätzlich zur Decimal Ganzzahl direkte Menge erkennt JavaScript auch die Werte des sechzehn Mechanismus (16) als Kardinalität. Das sogenannte hexadezimale System ist eine direkte Menge, die mit "0x" oder "0x" vorangestellt ist, gefolgt von einer Reihe von Hexadezimalzahlen. Der hexadezimale Wert besteht aus Buchstaben zwischen 0-9 und a (a) -f (f). Die Buchstaben von AF sind in den folgenden Zahlen 10-15 ausgedrückt. Hier sind Beispiele für direkte Mengen von Hexadezimalzahlen

Die Codekopie lautet wie folgt:

0xff // 15*16+15 = 255

0xcafe911

Obwohl ECMascript keine Octal -direkten Größen unterstützt, können einige Implementierungen von JavaScript die Darstellung von Ganzzahlen in Oktal ermöglichen (Basis 8). Die Oktal -Direktmenge beginnt mit der Zahl 0, gefolgt von einer Abfolge von Zahlen zwischen 0 und 7.

Die Codekopie lautet wie folgt:

0377 // 3*64 +7*8 +7 = 255 (Dezimal)

Da einige JavaScript-Implementierungen die Octal-Zwischenabnummer unterstützen, aber nicht, ist es am besten, nicht mit 0 vorangestellte Integer-Zwischenabnumme zu verwenden. Schließlich können wir nicht wissen, ob die aktuelle JavaScript-Implementierung die Octal Parsing unterstützt. Im strengen Modus von ECMascript6 ist die direkte Oktalmenge explizit verboten.

ii. Schwebende Punkt direkte Menge

Direkte Mengen schwimmender Punkte können Dezimalpunkte enthalten und verwenden die traditionelle Real -Nummern -Schreibmethode. Eine reale Zahl besteht aus einem ganzzahligen Teil, einem Dezimalpunkt und einem Dezimalteil.

Darüber hinaus kann die exponentielle Zählmethode auch zur Darstellung von Direktmengen der schwimmenden Punkte verwendet werden. Das heißt, die reale Zahl folgt vom Buchstaben E oder E, gefolgt vom positiven und negativen Vorzeichen, und dann wird ein ganzzahliger Exponent hinzugefügt. Der durch diese Zählmethode dargestellte numerische Wert ist eine exponentielle Leistung der vorherigen reellen Zahl multipliziert mit 10.

Kann in einer prägnanteren Syntax ausgedrückt werden

Die Codekopie lautet wie folgt:

[Ziffern] [. Ziffern] [(e | e) [(+|-)] Digits]

3.14

2345.455

.333333333333333333333333333333333

6.02e23 //6.02*10 zur 23. Leistung

1.255454e-23 //1.255454*10 zur 23. Leistung

Arithmetische Operation in iii.javaScript

JavaScript -Programme verwenden arithmetische Operatoren, die von der Sprachprovinz zur Durchführung numerischer Operationen bereitgestellt werden. Diese Operatoren enthalten + - * / und den verbleibenden (geteilten Rest-) Operator %

Neben grundlegenden Operatoren unterstützt JavaScript auch komplexere arithmetische Operationen. Dieser Betriebsvorgang wird durch Funktionen und Konstanten implementiert, die als Eigenschaften mathematischer Objekte definiert sind.

Die Codekopie lautet wie folgt:

Math.Pow (2, 53) // => 9007199254740992 Dokument.Write (Math.Pow (2,53))

Math.round (.6) //=>1.0 Runde

Math.ceil (.6) //=>1.0 Aufwärtssuche

Math.floor (.6) //=>0.0 Downwards

Math.abs (-5) // => 5 Finden Sie den Absolutwert

Math.max (x, y, z) // den Maximalwert zurückgeben

Math.min (x, y, z) // den Mindestwert zurückgeben

Math.random () // generieren Sie eine Pseudo-Random-Zahl von mehr als 0 und weniger als 1

Math.pi // pi

Math.e // e: Die Basis des natürlichen Logarithmus

Math.sqrt (3) // 3 Quadratwurzel

Math.pow (3, 1/3) // 3's Würfelwurzel

Math.sin (0) // Trigonometrische Funktionen sowie Math.cos, Math.atan usw.

Math.log (10) //= >2.302585092994046 Natürlicher Logarithmus mit Basis 10

Math.log (512) /Math.ln2 // Protokoll von 512 mit Basis 2

Math.log (100) /Math.ln10 // Protokoll von 100 mit Basis 10

Math.exp (3) // E's Kraft von drei

Arithmetische Operationen in JavaScript melden keine Fehler, wenn Überlauf, Unterströmung oder durch Null teilbar sind. Das numerische Betriebsergebnis überschreitet jedoch die Zahl, die in JavaScript (Überlauf) dargestellt werden kann, und das Ergebnis ist ein spezieller Infinite -Wert (unendlicher) Wert, der in JavaScript als unendlich ausgedrückt wird. Wenn der Wert der negativen Zahl den Bereich der negativen Zahlen überschreitet, die JavaScript ausdrücken kann, ist das Ergebnis negativ unendlich, was als in JavaScript als infisch ausgedrückt wird. Die Verhaltenseigenschaften von Unendlichkeitswerten stimmen mit dem überein, was wir erwarten: Das Ergebnis von Addition, Subtraktion, Multiplikation und Aufteilung basierend auf ihnen ist unendlich (die Vorzeichen)

Der Unterfluss ist eine Situation, die auftritt, wenn das Berechnungsergebnis drahtlos nahe Null ist und kleiner als der minimale Wert ist, den JavaScript darstellen kann. Wenn eine negative Zahl unterliegt, gibt JavaScript einen speziellen Wert "negatives Null" zurück, der (negatives Null) fast genau wie bei der Normalen Null ist. JavaScript -Programmierer verwenden selten negative Nullen.

JavaScript vordefinierte globale Variablen Infinaty und NAN, um nicht numerische Werte auszudrücken. In ECMASCIPT3 können diese beiden Werte gelesen und geschrieben werden. ECMascript5 hat dieses Problem behoben, indem sie als schreibgeschützte Definition definierten. Der vom Zahlenobjekt in ECMASCIPT3 definierte Attributwert ist ebenfalls schreibgeschützt. Hier finden Sie einige Beispiele:

Die Codekopie lautet wie folgt:

Infinity // Initialisieren Sie eine lesbare/Schreibvariable in Unendlichkeit

Number.positiv_infinity // gleicher Wert, nur lesen

1/0 // Dies ist der gleiche Wert

Nummer.max_Value + 1 // Das Berechnungsergebnis ist immer noch unendlich unendlich

Number.negative_infinity // bezeichnet negative Unendlichkeit

-Unendlichkeit

-1/0

-Number.max_value -1

NAN // Initialisieren Sie eine lesbare/Schreibvariable in NAN

Number.nan // gleicher Wert, aber nur lesen

0/0 // Das Berechnungsergebnis ist immer noch NAN

Number.min_value/2 // Unterlauf ist aufgetreten. Berechnete Ergebnis ist 0

-Number.min_value/2 // negatives Null

-1/Infinity // negative Null

-0 // negative Null

Nicht numerische Werte in JavaScript, die nicht gleich Menschen und Werten sind, einschließlich sich selbst. Mit anderen Worten, es ist unmöglich zu beurteilen, ob X von X == Nan ist. Stattdessen sollte X verwendet werden! = x zu beurteilen, dass, wenn x Nan ist, das Ergebnis des Ausdrucks wahr ist. Die Funktion isnan () ist ähnlich zu dieser. Wenn der Parameter NAN oder ein nicht numerischer Wert ist (z. B. eine Zeichenfolge und ein Objekt), gibt er True zurück. In JavaScript gibt es eine ähnliche Funktion, die isFinite () zurückgibt, wenn die Parameter nicht nan, unendlich oder -Infinity sind.

Der negative Nullwert ist ebenfalls etwas speziell. Es ist gleich positiver und negativer Null (selbst unter Verwendung des strengen Gleichstellungstests von JavaScript beurteilt), was bedeutet, dass diese beiden Werte fast genau gleich sind, außer wie ausschließend:

Die Codekopie lautet wie folgt:

var Zero = 0;

var negz = -0;

Null === Negz // => Die Werte der positiven und negativen Null sind gleich

1/null === 1/negz // falsch positive Unendlichkeit und negativer Unendlichkeit sind unterschiedlich

IIII. Binärer schwimmender Punktzahl und Rundungsfehler

Es gibt unzählige reale Zahlen, aber JavaScript kann nur endliche Zahlen durch die Form der schwimmenden Punktzahlen darstellen (um genau zu sein, gibt es 18 437 736 874 454 810 627), dh wenn reale Zahlen im JavaScript verwendet werden, ist dies häufig nur eine ungefähre Darstellung des realen Werts.

JavaScript übernimmt die IEEE-754-Schwimmpunktnummernnotation (verwendet von fast allen modernen Programmiersprachen). Dies ist eine binäre Darstellung, die Fraktionen genau darstellen kann, z. B. 1/2 1/8 und 1/1024. Leider basieren die Brüche, die wir häufig verwenden, insbesondere in Finanzberechnungen, auf Dezimalbrüchen 1/10, 1/100 usw. Binärnotation kann keine einfache Zahl wie 0,1 darstellen.

Zahlen in JavaScript haben eine ausreichende Präzision. Und kann nahe bei 0,1 sein. Tatsächlich bringt die Unfähigkeit, die Zahlen genau auszudrücken, einige Probleme.

Die Codekopie lautet wie folgt:

var x = .3 - .2;

var y = .2 - .1;

alarm (x == y) // => FALSCH Die beiden Werte sind nicht gleich

x == .1 // => false .3-.2 entspricht nicht .1

y == .1 // => true .2-.1 gleich 1

Aufgrund des Rundungsfehlers entspricht die ungefähre Differenz zwischen 0,3 und 0,2 nicht der ungefähren Differenz zwischen 0,2 und 0,1 (in realen Simulationsumgebungen 0,3-0,2 = 0,099 999 999 999 999 999 999 98). Dieses Problem ist nicht nur in JavaScript vorhanden, es ist auch sehr wichtig, dies zu verstehen: Dieses Problem tritt in jeder Programmiersprache auf, die binäre schwimmende Punktzahlen verwendet. Es ist auch wichtig zu beachten, dass die Werte von x und y im obigen Code sehr nahe beieinander und die endgültigen korrekten Werte sind. Dieses Berechnungsergebnis kann für die meisten Berechnungsaufgaben kompetent sein. Dieses Problem tritt nur beim Vergleich, ob die beiden Werte gleich sind.

Zukünftige Versionen von JavaScript können dezimale numerische Typen unterstützen, um dieses Problem zu vermeiden, bevor Sie es möglicherweise vorziehen, große Ganzzahlen für wichtige finanzielle Berechnungen zu verwenden. Verwenden Sie beispielsweise Integer "Segmente" anstelle von dezimalen "Elementen" für Geldeinheiten.

iiiii.date und Zeit

Der Kern der JavaScript -Sprache enthält den Date () -Konstruktor, der ursprünglich Objekte von Datum und Uhrzeit erstellt hat. Die Methoden dieser Datumsobjekte bieten eine einfache API für die Berechnung des Datums. Datumsobjekte können kein grundlegender Datentyp wie Zahlen sein.

Die Codekopie lautet wie folgt:

var zhen = neues Datum (2011, 0, 1); // 1. Januar 2011

var später = neues Datum (2011, 0, 1, 17, 10, 30); // selben Tag

var nun = new Date (); // das aktuelle Datum und die aktuelle Uhrzeit

var verstrichen = jetzt - Zhen; // Subtraktion Datum. Berechnen Sie die Anzahl der Millisekunden des Zeitintervalls

später. // => 2011

später.getMonth (); // => 0 Monate von 0 gezählt

später.GetDate (); // => 1 Die Anzahl der Tage von 1 gezählt

später.getday (); // => 5 Erhalten Sie den Wochentag. 0 repräsentiert Sonntag, 5 repräsentiert Sonntag

später.Gethours () // => Lokale Zeit

später.Getutchours () // UTC verwenden, um die Zeit der Stunde auf der Grundlage der Zeitzone darzustellen.

2. Text

Eine Zeichenfolge ist eine unveränderliche und geordnete Sequenz von 16-Bit-Werten, jedes Zeichen stammt normalerweise von einem Unicode-Zeichensatz. JavaScript repräsentiert Text über Zeichenfolgetypen. Die Länge einer Zeichenfolge beträgt die Anzahl von 16-Bit-Werten, die sie enthält. Der Index einer JavaScript -Zeichenfolge (und sein Array) beginnt bei 0. Die Länge der 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 Saite beträgt 1.

Zeichensatz, innerer Code und JavaScript -Zeichenfolge

JavaScript verwendet einen Utf-16-kodierten Unicode-Zeichensatz, und eine JavaScript-Zeichenfolge ist eine Sequenz, die aus einer Reihe von nicht ordnungsgemäßen 16-Bit-Werten besteht. Die am häufigsten verwendeten Unicode-Zeichen werden durch 16-Bit-Innencodes dargestellt und ein einzelnes Zeichen in der Zeichenfolge dargestellt. Unicode-Zeichen, die nicht als 16-Bit dargestellt werden können, folgen die UTF-16-Codierungsregeln-unter Verwendung von zwei 16-Bit-Werten, um eine Sequenz zu bilden (auch als "Proxypaare" bezeichnet). Dies bedeutet, dass eine JavaScript-Zeichenfolge von Länge 2 (zwei 16-Bit-Werte) ein Unicode-Zeichen darstellen kann.

Die Codekopie lautet wie folgt:

var p = "π"; // π wird durch 16-Bit-Innencode 0x03c0 dargestellt

var e = "e"; // e wird durch 17-Bit-Innencode 0x1d452 dargestellt

P.Length // => 1 P enthält einen 16-Bit-Wert

E.Length // => 2 E codiert von UTF-16 enthält zwei Werte: "/ud835/udc52"

Alle durch JavaScript definierten String-Betriebsmethoden wirken auf 16-Bit-Werte, nicht auf Zeichen, und verarbeiten das Proxy-Element nicht separat. In ähnlicher Weise standardisiert JavaScript die String -Verarbeitung nicht. Es gibt keine Garantie dafür, dass Saiten das legale UTF-16-Format sind

I String Direct -Menge

Eine direkte Menge von Zeichenfolgen in einem JavaScript -Programm ist eine Abfolge von Zeichen, die von einzelnen Zitaten oder doppelten Zitaten eingeschlossen sind. Eine durch einzelne Zitate begrenzte Zeichenfolge kann doppelte Zitate enthalten, und eine durch doppelte Anführungszeichen abgenommene Zeichenfolge kann auch einzelne Zitate enthalten. Hier sind einige Beispiele für die direkte Quantifizierung von Zeichenfolgen.

Die Codekopie lautet wie folgt:

"// leere Zeichenfolge, 0 Zeichen

'Testen'

"3.14"

'name = "myform"' ''

"Würden Sie O'Reilys Buch nicht bevorzugen?"

In ECMascript3 muss die direkte Menge der Zeichenfolge in einer Zeile geschrieben werden, während in ECMascript5 die direkte Menge der Zeichenfolge in mehrere Zeilen aufgeteilt werden kann und jede Zeile mit einem Rückgang (/) enden muss. Weder der Backslash noch das Zeilenende -Zeichen sind der Inhalt der direkten Menge der Zeichenfolge. Wenn Sie zusammen sein möchten, können Sie /n verwenden, um die Zeichen zu entkommen.

Es ist zu beachten, dass Sie bei der Verwendung einzelner Zitate zum Abgrenzungszeichenfolgen besonders vorsichtig mit den Abkürzungen und allen Formaten in englischer Sprache sein müssen. Englische Apostrophen und einzelne Zitate sind das gleiche Zeichen, daher müssen Backslashes (/) verwendet werden, um zu entkommen.

II entkommen Charaktere

In JavaScript -Zeichenfolgen haben Backslashes (/) einen besonderen Zweck. Das Hinzufügen eines Charakters zu den Backslashes repräsentiert ihre wörtliche Bedeutung nicht mehr. Zum Beispiel ist /n ein Fluchtcharakter, der eine neue Linie darstellt.

Die Codekopie lautet wie folgt:

/o // nul Zeichen

/B // Rückraumcharakter

/t // Horizontaler Registerkartenzeichen

/n // Neue Line Newline -Zeichen

/v // vertikaler Registerkartenzeichen

/f // Seitenverengung

/r // Wagenrücklaufcharakter

/"// Doppelzitate

// Backslash

/xxx latin-1-Zeichen, angegeben durch zwei-Bit-Hexadezimal

/xxxxxxx Unicode Zeichen, angegeben durch vier-Bit-Hexadezimal xxxxx

Verwendung der III -Zeichenfolge

Eines der integrierten Merkmale von JavaScript ist die String-Verkettung. Verwenden Sie Operator + für Zeichenfolgen, um die String -Verkettung darzustellen. Zum Beispiel

Die Codekopie lautet wie folgt:

var msg = "Hallo" + "Welt"; // generiere die String Hello World

Um die Länge einer Zeichenfolge zu bestimmen - die Anzahl von 16 -Bit -Werten, 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 bieten Zeichenfolgen auch viele Methoden, die aufgerufen werden können.

Die Codekopie lautet wie folgt:

var s = "Hallo, Welt";

S. charat (0); // "H" Erster Charakter

S.Charat (S.Length - 1) // "D" Letzter Zeichen

substring (1, 4) // "ell" 2-4 Zeichen

S.Slice (1, 4) // Ell wie oben

S.Slice (-3) // Die letzten 3 Zeichen werden angezeigt

S.Intexof (l ") // 2 Zeichen L Die erste Vorkommensposition

s.lastindexof ("l") // 10 beim letzten Mal, als das Zeichen L erscheint

S.Indexof ("L", 3) // nach Position 3, die erste Position, in der das L -Zeichen erscheint

S.Split (",") // => ["Hallo", "Welt"] ist in Unterstrings unterteilt

S.Replace ("H", "H") // => "Hllo, World" Volltext Charakterersatz

S.Touppercase () // => "Hallo, Welt"

In JavaScript sind Zeichenfolgen fest und unverändert. Methoden wie Ersatz () und Touppercase () geben neue Zeichenfolgen zurück, und die Originalfiguren selbst haben sich nicht geändert.

In ECMascript können Zeichen als schreibgeschützte Arrays behandelt werden. Zusätzlich zur Verwendung der Charat () -Methode können Quadratklammern verwendet werden, um auf einzelne Zeichen in einer Zeichenfolge zuzugreifen. (16-Bit-Wert)

Die Codekopie lautet wie folgt:

S = "Hallo, Welt"

s [0] // => "H"

s [S.Length-1] // => "D"

Foxfire hat vor langer Zeit die String -Indexierung für diese Methode unterstützt, und die meisten modernen Browser (mit Ausnahme von IE) folgten Mozaillas Fußstapfen und absolvierten dieses Feature, bevor ECMascript gebildet wurde.

IIII -Muster -Matching

JavaScript definiert den Regexp () -Konstruktor, mit dem Objekte erstellt werden, die das Abgleich von Textmustern darstellen. Diese Muster werden als "reguläre Ausdrücke", reguläre Expressionsyntax in JavaScript Perl bezeichnet. Sowohl String- als auch Regexp -Objekte definieren Funktionen, die regelmäßige Ausdrücke verwenden, um Muster zu übereinstimmen, zu ermitteln und zu ersetzen.

Das Regexp -Objekt ist kein grundlegender Datentyp in der Sprache. Wie Datum ist es nur ein spezielles Objekt mit einer praktischen API. Regelmäßige Ausdrücke haben eine komplexe Syntax und eine reiche APIs. Es wird in Kapitel 10 ausführlich eingeführt. Regexp ist ein leistungsstarkes und häufig verwendetes Textverarbeitungsinstrument, und hier ist nur eine Übersicht.

Obwohl Regexp in der Sprache kein grundlegender Datentyp ist, haben sie immer noch direkte Mengen und können direkt in JavaScript verwendet werden. Der Text zwischen zwei Schrägstrichen bildet eine direkte Menge eines regulären Ausdrucks. Der zweite Schrägstrich kann auch einem oder mehreren Buchstaben folgen. Wird verwendet, um die Bedeutung des Matching -Musters zu ändern. Zum Beispiel:

Die Codekopie lautet wie folgt:

/^Html/// Übereinstimmung Strings beginnend mit HTML

/[1-9] [0-9]*// mit einer Nummer ungleich Null übereinstimmen, gefolgt von einer beliebigen Zahl

// BjavaScript/B/i/// mit dem Wort JavaScript übereinstimmen und den oberen und unteren Fall ignorieren

Das Regexp -Objekt definiert viele nützliche Methoden, und Zeichenfolgen haben auch Methoden, mit denen die REGEXP -Parameter akzeptiert werden können. Zum Beispiel:

Die Codekopie lautet wie folgt:

var text = "testing: 1,2,3"; // Textbeispiel

var muster = // d+/g // überein alle Instanzen mit einer oder mehreren Zahlen übereinstimmen

muster.test (text) // => true: Die Übereinstimmung ist erfolgreich

text.Search (Muster) // => 9: Die Position, in der die erste Übereinstimmung erfolgreich war

Text.Match (Muster) // => ["1", "2", "3"] Alle entsprechen einem Array

text.repeat (Muster, "#"); // => "Testen:#,#,#"

text.split (// d+/); // => ["", "1", "2", "3"]: Verwenden Sie nicht numerische Zeichen, um Zeichenfolgen abzufangen

3. Boolesche Wert

Boolesche Werte beziehen sich auf True oder False, ein oder aus. Dieser Typ hat nur zwei Werte, und das Wort wahr oder falsch ist reserviert.

Die Ergebnisse von Vergleichsanweisungen in JavaScript sind normalerweise boolesche Werte. Zum Beispiel

A == 4

Dieser Code wird verwendet, um festzustellen, ob der Wert einer Variablen gleich 4 ist. Wenn er gleich ist, ist der Wert wahr, wenn der Wert nicht gleich ist, falsch, falsch

Boolesche Werte werden normalerweise in JavaScript -Kontrollanweisungen verwendet, z. B. wenn/sonst Anweisungen in JavaScript. Wenn der boolesche Wert wahr ist, führen Sie das erste Stück Logik aus und wenn ein anderes Code -Stück falsch ist, z.

Die Codekopie lautet wie folgt:

if (a == 4)

B = B + 1;

anders

a = a + 1;

Jeder JavaScript -Wert kann in boolesche Werte konvertiert werden, und die folgenden Werte werden in False konvertiert

Die Codekopie lautet wie folgt:

undefiniert

NULL

0

-0

Nan

"// leere Zeichenfolge

Alle anderen Werte, einschließlich aller Objekte (Arrays), werden in true, false konvertiert, und die oben genannten 6 Werte, die in False konvertiert werden können, werden manchmal als "falsche Werte" bezeichnet. JavaScript erwartet, dass bei Verwendung eines booleschen Wertes der falsche Wert als falsch behandelt wird und der wahre Wert als wahr behandelt wird.

Schauen wir uns ein Beispiel an. Das Hinzufügen der Variablen O ist ein Objekt oder ein Null. Sie können eine IF-Anweisung verwenden, um festzustellen, ob o ein Nicht-Null-Wert ist.

if (o! == null) ...

Der ungleiche Operator "! ==" vergleicht O und Null und gibt das Ergebnis wahr oder falsch. Sie können zuerst die Vergleichserklärung hier ignorieren. Null ist ein falscher Wert und das Objekt ist ein wahrer Wert.

Wenn (o) ...

Für den ersten Fall wird der Code danach nur ausgeführt, wenn O nicht null ist und die Einschränkungen des zweiten Falls nicht so streng sind. Dies wird nur ausgeführt, wenn O nicht falsch oder falsch ist (z. B. null oder unfuriert).

Boolean enthält die Methode toString (), sodass Sie diese Methode verwenden können, um eine Zeichenfolge in "true" oder "false" zu konvertieren, aber keine anderen nützlichen Methoden enthält, und zusätzlich zu dieser unwichtigen API gibt es drei wichtige boolesche Operatoren.

&& Operator, || Operator und Unary Operator "!" Führen Sie einen booleschen Nicht (nicht) Operation durch. Wenn der wahre Wert false zurückgibt, gibt der falsche Wert beispielsweise die wahr

Die Codekopie lautet wie folgt:

if ((x == 0 && y == 0) ||! (z == 0)) {

// x und y sind beide Null oder Z sind ungleich Null

}

4. Null und undefiniert

Null ist ein Schlüsselwort in der JavaScript -Sprache. Es stellt einen besonderen Wert "Nullwert" dar. Für NULL führt es den Operation typeof () durch und gibt Objekt zurück. Das heißt, Null kann als spezieller Objektwert betrachtet werden, was "Nicht-Objekt" bedeutet. Tatsächlich gilt Null jedoch normalerweise als das einzige Mitglied seines freien Typs. Es kann darstellen, dass Zahlen, Zeichenfolgen und Objekte "wertlos" sind. Die meisten Programmiersprachen enthalten null wie JavaScript, und Sie können mit Null oder Null vertraut sein.

JavaScript hat auch einen zweiten Wert, der die freie Stelle des Werts anzeigt. Wird verwendet, um tiefere "Nullwerte" darzustellen. Es ist ein Wert einer Variablen. Zeigt an, dass die Variable nicht initialisiert wurde. Wenn Sie den Wert eines Objektattributs oder eines Array -Elements abfragen möchten, gibt es undefined zurück. Dies bedeutet, dass das Attribut oder das Element nicht existiert. Undefiniert ist eine vordefinierte globale Variable (sie unterscheidet sich von Null, es ist kein Schlüsselwort) und sein Wert ist undefiniert. Wenn Sie Typen verwenden, um den undefinierten Typ zu testen, wird "undefiniert" zurückgegeben, was darauf hinweist, dass der Wert das einzige Mitglied des Typs ist.

Obwohl Null und Undefined unterschiedlich sind, repräsentieren beide "Werte von Werten", und die beiden sind oft austauschbar. Der Bediener, der Gleichheit beurteilt "==" ist der Meinung, dass die beiden gleich sind (verwenden Sie den strengen Gleichstellungsoperator "===", um sie zu unterscheiden). Wenn der Wert von einem Booleschen Typ erwartet wird, sind ihre Werte alle falsch. Ähnlich wie falsch. Sowohl Null als auch undefinierte enthalten keine Eigenschaften und Methoden. In der Tat mit "". " und "[]", um auf Mitglieder zuzugreifen, oder Methoden dieser beiden Werte erzeugen einen Typfehler.

Sie könnten denken, dass Undefined System auf Systemebene darstellt, unerwartet lebende offene Stellen falscher Werte, während NULL auf Programmebene, normale oder erwartete Werte für Werte darstellt. Wenn Sie sie in Variablen oder Eigenschaften kopieren oder als Parameter in eine Funktion übergeben möchten, ist NULL die beste Wahl.

5. Globale Objekte

In den vorherigen Abschnitten werden die Elementtypen und Originalwerte von JavaScript erörtert. Objekttypen - Objekte, Arrays und Funktionen / aber es gibt eine sehr wichtige Klasse von Objekten, die jetzt nicht klar sein dürfen: globale Objekte

Das globale Objekt hat wichtige Verwendungen in JavaScript. Die Eigenschaften eines globalen Objekts sind weltweit definierte Symbole. JavaScript -Programme können direkt verwendet werden. Wenn der JavaScript -Interpreter beginnt, erstellt er ein neues globales Objekt und gibt ihm eine Reihe definierter Anfangseigenschaften.

Globale Eigenschaften wie undefined Unendliche und Nan

Globale Funktionen wie Isnan (), ParseInt () und Eval ()

Konstruktoren wie Date (), regexp (), string (), Object () und Array ()

Globale Objekte wie Math und JSON

Das anfängliche Attribut eines globalen Objekts ist kein reserviertes Wort, sondern sollte als reserviertes Wort behandelt werden.

Auf der oberen Ebene des Code - JavaScript -Code, das nicht innerhalb einer Funktion ist, können Sie über das JavaScript -Schlüsselwort auf das globale Objekt verweisen.

var global = this; // Definieren Sie eine globale Variable, die ein globales Objekt verweist.

In Client JavaScript fungiert das Fensterobjekt als globales Objekt. Dieses globale Fensterobjekt hat selbst eine vertraute Fensterreferenz. Es kann dies ersetzen, um sich auf das globale Objekt zu beziehen. Windows definiert globale Kernattribute. Einige andere globale Attribute sind jedoch für Webbrowser und interaktives JavaScript definiert.

Wenn das globale Objekt zum ersten Mal erstellt wurde, definiert es alle vordefinierten globalen Werte in JavaScript, und dieses spezielle Objekt enthält auch die für das Programm definierten globalen Werte. Wenn der Code eine globale Variable deklariert. Diese globale Variable ist ein Attribut des globalen Objekts.

6. Verpackungsobjekt

Ein JavaScript -Objekt ist ein zusammengesetzter Wert: Es handelt sich um eine Sammlung von Attributen oder benannten Werten. Der Attributwert wird durch "." Wenn der Attributwert eine Funktion ist, handelt es sich um eine Methode und verwendet OM (), um die Methoden in Objekt O zu übertragen.

Wir sehen, dass Saiten auch Eigenschaften und Methoden haben.

Die Codekopie lautet wie folgt:

var s = "Hallo Welt";

var word = substring (S.Indexof ("")+1, s.Length); // Verwenden Sie die Attribute der Zeichenfolge.

document.write (word) // "Ello World"

Warum hat sie Eigenschaften, da eine Zeichenfolge kein Objekt ist? Solange das Attribut von String S referenziert wird, wandelt JavaScript den Wert der Zeichenfolge in ein Objekt um, indem neue Zeichenfolge aufgerufen werden, die die String -Methode erbt. und wird verwendet, um Attributreferenzen zu verarbeiten. Sobald das neue Attribut referenziert ist. Sobald die Referenz beendet ist, wird das neu erstellte Objekt zerstört. (Dieses temporäre Objekt erstellt oder zerstört nicht unbedingt, aber dieser Prozess sieht so aus.)

Wie Saiten haben auch Zahlen und Boolesche Werte ihre eigenen Methoden, wodurch ein temporäres Objekt über die Konstrukteure der Nummer () und boolean () erstellt wird. Alle diese Methoden werden aus diesem temporären Objekt aufgerufen. (Null und Undefined wurden nicht verpackt, dass auf ihre Eigenschaften zugegriffen wird. Es hat einen Typfehler.

Schauen Sie sich den folgenden Code an und denken Sie über ihren Ausführungsprozess nach

Die Codekopie lautet wie folgt:

var s = "test";

s.len = 4; // Setzen Sie eine Eigenschaft dafür

var t = s.len // Finden Sie diese Eigenschaft

Beim Ausführen dieses Codes ist der Wert von T undefiniert. Die zweite Codezeile erstellt ein temporäres String -Objekt und gibt Len einen Wert von 4. Das Objekt wird dann zerstört. Die dritte Zeile verwendet die ursprüngliche (nicht modifizierte) Zeichenfolge, um ein neues String -Objekt zu erstellen, und versucht, die Attribute von Len zu lesen.

Diese Eigenschaft existiert natürlich nicht, was darauf hinweist, dass das Ergebnis undefiniert ist. Dieser Code zeigt, dass beim Lesen der Eigenschaftswerte (oder der Methoden) von Zeichenfolgen, Arrays und booleschen Werten sich er wie ein Objekt verhält, wenn Sie jedoch versuchen, seiner Eigenschaft einen Wert zuzuweisen. Diese Operation wird ignoriert; Die Änderung kommt nur an temporäre Objekte. Dieses temporäre Objekt wurde nicht beibehalten.

Es ist zu beachten, dass die Erstellung von Wrapper -Objekten über die Konstruktoren String (), Number () und Boolean () angezeigt werden kann:

Die Codekopie lautet wie folgt:

var s = "test",

n = 1,

B = wahr;

var s = neue Zeichenfolge (s);

var n = neue Zahl (n);

var b = neuer boolean (b);

JavaScript wandelt den Wrapper bei Bedarf in den ursprünglichen Wert um, sodass das Objekt -SNB im vorherigen Code häufig - aber nicht immer - den gleichen Wert wie SNB darstellt, "==", der dem Operator entspricht, behandelt den ursprünglichen Wert und sein Wrapper -Objekt als gleich.

Der vollständige Operator "===" behandelt sie jedoch als Ungleichheit, und der Unterschied zwischen dem ursprünglichen Wert und dem Objekt, das er wickelt, kann durch den Typeof -Operator angezeigt werden.

7. Unveränderliche Originalwerte und veränderliche Objektreferenzen.

Der ursprüngliche Wert von JavaScript (undefinierte Null -Boolesche Nummern und Zeichenfolgen) unterscheidet sich grundlegend von Objekten (einschließlich Arrays und Funktionen). Der ursprüngliche Wert ist unveränderlich; Keine Methode kann einen primitiven Wert mutieren (oder mutieren). Es gilt offensichtlich für Zahlen und Boolescheer - das Ändern des Wertes einer Zahl macht an sich keinen Sinn, aber es ist nicht so offensichtlich für Saiten, da Zeichenfolgen eine Reihe von Charakteren zu sein scheinen. Wir erwarten, dass Zeichen in der Zeichenfolge durch den angegebenen Index geändert werden können. Tatsächlich verbietet JavaScript dies. Alle Methoden in der Zeichenfolge scheinen eine modifizierte Zeichenfolge zurückzugeben, die eigentlich eine neue Zeichenfolge ist.

Die Codekopie lautet wie folgt:

var s = "Hallo Welt";

S.Touppercase (); // "Hello World" zurückgeben und den Wert von s nicht verändert

S // => "Hello World" hat sich nicht geändert

原始值的比较是值的比较，只有在他们的值相当时它们在才相等。这对数字、布尔值、null和undefined来说听起来有点难，并没有其他办法来比较他们。同样，对于字符串来说则不那么明显；如果比较两个单独的字符串，当且仅当他们的长度相等且每个索引的字符都相等时，javascript的才认为相等。

Die Codekopie lautet wie folgt:

var o = {x:1} //定义一个对象

ox = 2 //通过修改对象的属性来改变对象

oy = 3 //再次更改这个对象，给它增加一个新属性

var a =[1,2,3] //数组也是可以修改的

a[0]=0; //更改数组中的一个元素

a[3]=4; 给数组增加一个新元素

对象的比较并非值的比较：即使两个对象包含同样的属性及相同的值，他们也是不相等的，各个索引元素完全相等的两个数组也不相等

Die Codekopie lautet wie folgt:

var o ={x:1}, p={x:1}//两个具有相同属性的两个对象

o === p ;//=>false 两个单独的对象永不相等( o == p ; =>false)

var a =[],b=[]; //两个单独的空数组

a === b ; //=>false两个单独的数组永不相等

我们通常将对象称为引用类型(reference type),以此来和javascript的基本类型区分开来。依照术语的叫法，对象都是引用(reference),对象的比较均是引用的比较；当且当它们应用同一个基对象时，它们才相等。

Die Codekopie lautet wie folgt:

var a = []; //定义一个引用空数组的变量a

var b = a; //变量b引用同一个数组

b[0] = 1;

a[0] //=>1 变量a也会修改

a === b //=>true a和b引用同一个数组，因此他们相等。

就像你刚才看到的如上代码，将对象（或数组）赋值给一个变量，仅仅是赋值的引用值：对象本身并没有复制一次。

如果你想得到一个对象或数组的副本，则必须显式复制对象的每个属性或数组的每个元素。下面的这个例子则是通过循环来完成对数组的复制。

Die Codekopie lautet wie folgt:

var a = ['a', 'b', 'c']; //待复制的数组

var b = []; //复制到目标的空数组

for (var i = 0; i < a.length; i++) { //遍历a[]中的每个元素

b[i] = a[i]; //将元素复制到b中。

}

同样的，如果我们想比较两个单独或者数组，则必须比较他们的属性或元素。下面这段代码定义了一个比较练个数组的函数。

Die Codekopie lautet wie folgt:

function equalArrays(a, b) {

if (a.length != b.length) return false; //两个长度不相同的数组不相等

for (var i = 0; i < a.length; i++) //循环遍历所有元素

if (a[i] !== b[i]) return false; //如果有任意元素不等，则数组不相等

zurückkehren; // Otherwise they are equal

}

8.类型转化

javascript中的取值型非常灵活，我们已经从布尔值看到了这一点：当javascript期望使用一个布尔值时候，你可以提供任意类型值。javascript将根据需要自行转换类型。一些值（真值）为true，其它值（假值）转化为false.这在其它类型中同样适用。如果javascript期望使用一个字符串，它把给定的值转换为字符串。如果javascript期望使用一个数组，它把给定的值转换为数字（如果转化结果无意义的话将返回NaN）,一些例子如下：

Die Codekopie lautet wie folgt:

10 + "object" //=> "10object";

"7" * "4" // =>28 两个字符串均转化为数字

var n = 1 - "x" // =>NaN字符串x无法转换为数字

n + " objects" // =>"NaN objects":NaN转换为字符串"NaN"

下表说明了在javascript中如何进行类型转化。粗体突出了那些让你倍感意外的类型转化。空单元格表示不必要也没有执行的转换。

上表提到的原始值到原始值的转换行对简单，我们已经在第本文第三小节讨论过转换为布尔值的情况了。所有原始值转换为字符串的情形也已经明确定义。转换为数字的情形比较微妙。那些以数字表示的字符串可以直接转化为数字，也允许在开始和结尾处带有空格。但在开始和结尾处的任意非空字符都不会被当成数字量的一部分，进而造成字符串为数字的结果为NaN。有一些数字转换看起来让人奇怪：true转换为1，false、空字符串""转换为0.

原始值到对象的转换也非常简单，原始值通过调用String()，Number()或Boolean()构造函数，转化为它们各自的包装对象。见本文第6节。

null和undefined属于例外，当将它们用在期望是一个对象的地方都会造成一个类型错误(TypeError)异常。而不会执行正常的转换。

对象到原始值的转换多少有些复杂，本小节第三小节有专门描述。

ich. Conversion and Equality

由于javascript可以做灵活的类型转换，因此其“==”相等运算符也随相等的含义灵活多变。例如：如下这些比较结果均是true；

null == undefined //这两值被认为相等

"0" == 0 //在比较之前，字符串转换成数字。

0 = false //在这之前布尔值转换成数字。

"0" ==false //在比较之前字符串和布尔值都转换成数字

在第四章9节第一小节相信讲解了“==”等于运算符在判断两个值是否相等时做了那些类型转换，并同样介绍了“===”恒等运算符在判断相等时并未做任何的类型转换。

需要特别注意的是：一个值转换为另一个值并不意味着两个值相等。比如在期望使用布尔值的地方使用了undefined，将会转换为false，但这不表明undefined==false。javascript运算符和语句期望使用多样化的数据类型，并可以互相转换。if语句将undefined转化为false,但“==”运算符从不试图将其转化为布尔值。

ii.显式类型转化

尽管javascript可以做做很多类型转换，但有时仍需要做显式转换，或者为了使代码变得清晰易读而做显式转换。

做显式转换最重简单的方法就是使用Boolean()、Number()、String()或Object函数。我们在本文第6节已经介绍过了. 当不通过new运算符调运这些函数时，他们会作为类型转换函数并按照上边表格所描述的规则做类型转换。

Die Codekopie lautet wie folgt:

Number("3") //=>3

String(false) //=>"false"或使用false.toString()

Boolean([]) //=>true

Object(3) // =>new Number(3)

需要注意的是，除了null或undefined之外的任何值都具有toString()方法，在这个方法的执行结果通常和String()方法返回的结果一致。同样需要注意的话，如果试图把null或undefined转化为对象。则会抛出一个类型错误typeerro。Object()函数在这种情况下不会抛出异常：它仅简单返回一个新创建的空对象。

javascript中的某些运算符会做隐式的类型转换，有时用于类型转换。如果“+”运算符的一个操作数是字符串，它将会把令一个操作数转换为字符串。一元“+”运算符将其操作数转换为数字。同样，一元“！”运算符将其操作数转换为布尔值取反，在代码中常会看到这种类型转换的惯用法。

Die Codekopie lautet wie folgt:

x + "" // 等于字符串String(x)

+x //等价于Number(x),也可以写成x-0

!!x //等价于Boolean(x)

在计算机中数字的解析和格式化代码是非常普通的工作。javascript中提供了专门的函数和方法用来更加精确的数字到字符串（number-to-string）和字符串到数字(string-to-number)的抓换。

Nmuber类定义的toString()方法可以接收表示基数（二进制，八进制，十六进制等）的可选参数，如果不指定该参数，转化规则将是十进制。同样也可以将数字转换为其它进制数。（范围在2-36之间）

Die Codekopie lautet wie folgt:

var n = 17;

b_string = n.toString(2); //转化为10001

o_string = "0" + n.toString(8); //转化为八进制021

hex_string = "0x" + n.toString(16); //转化为16进制0x11

javascript为控制输出中小数点位置和有效数字位数，或者决定是否需要指定指数计数法。Number类为这种数字到字符串定义了三个方法。

toFixed()根据小数点后指定位数，将数字转换为字符串，它从不使用指数计数法。toExponential()使用指数计数法，将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位置则由参数指定（也就是说有效数字位数要比指定的位数多一位）。toPrecision()根据指定的有效数字位数，将数字转换为字符串。如果有效数字的位数小于数字整数部分的位数，则转换成指数形式。我们注意到，三个方法都会适当的进行四舍五入或填充0,

Die Codekopie lautet wie folgt:

var n = 123456.789;

n.toFixed(0); //"123457"

n.toFixed(2); //"123456.79"

n.toFixed(5); //"123456.78900"

n.toExponential(1); //"1.2e+5"

n.toExponential(3); //"1.235e+5"

n.toPrecision(4); // "1.235e+5"

n.toPrecision(7); //"123456.8"

n.toPrecision(10); //"123456.7890"

如果通过Number()转换函数传入一个字符串，它会试图将其转化为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且不能出现非法的尾随字符。parseInt()和parseFloat()函数（它们是全局函数，不属于人和类的方法），更加灵活。parseInt()只解析整数。而parseFloat()则可以解析整数和浮点数。如果字符串前边是0x或0X,parseInt()将其解析为16进制数。两个方法都会跳过任意量的前导空格，尽可能解析更多数值字符。并忽略后边的内容。如果第一个是非法的数字直接量，则返回NaN

Die Codekopie lautet wie folgt:

parseInt("3many nice") //=>3;

parseFloat("3.14meters") //=>3.14

parseInt("-12.34") //=>-12

parseInt("0xff") //=>255

parseInt("-0XFF") //=>-255

parseFloat(".1") // =>0.1

parseInt("0.1") //=> 0

parseInt(".1") //=>NaN 不能以.开始

parseInt("$112") //=>NaN 不能以$开头

parseInt()可以接收第二个可选参数。这个参数指定数字转换的基数。合法的取值范围是2-36

Die Codekopie lautet wie folgt:

parseInt("11", 2) //=>3(1*2+1)

parseInt("ff", 16) //=> 255(15*16 +15)

parseInt("zz", 36) //=>1295(35*36+35)

parseInt("077", 8) // 63(7*8 +7)

parseInt("077", 10) //77(7*10+7)

iii.对象转化为原始值。

对象到布尔值的转换非常简单：所有的对象（包括数组和函数）都转换为true。对于包装对象亦是如此，new Boolean(false)是一个对象而不是原始值，它将转换为true。 对象到字符串（object-to-String）和对象到数字(object-to-number)的转换是通过调用带转换对象的一个方法来完成的。一个麻烦的事实是，javascript对象有两个不同的方法来执行转换，并且接下来要讨论并且接下来要讨论的场景更加复杂。值得注意的是，这里提到的字符串和数字的转换规则只适用于本地对象（native fangf object）.宿主对象(例如：由web浏览器定义的对象)，根据各自的算法可以转换成字符串和数字。

所有的对象继承了两个转换方法。第一个是toString(), 它的作用是返回一个反映这个对象的字符串。默认的toString()方法并不会返回一个有趣的值。

({x:1,y:2}).toString() //=>"[object object]"

很多类定义了更多特定版本的toString()方法.

例如：数组类(Array class)的toString()方法将每个数组元素转换为一个字符串，并在元素之间添加逗号后并合成结果字符串。

函数类(Function class)的toString()方法返回这个函数的实现定义的表示方式。实际上，这里的实现方式是通常是将用户定义函数转换为javascript源代码字符串。

日期类(Date class)定义toString()方法返回一个可读的（可被javascript-parsable解析的）日期和事件字符串

RegExp class定义的toString()方法将RegExp对象转换为正则表达式直接量字符串。

Die Codekopie lautet wie folgt:

[1, 2, 3].toString(); //=> "1,2,3"

(function(x) {f(x);}).toString(); // =>"function(x){/nf(x); /n}"

//d+/g.toString(); //=> ///d+/g

new Date(2015, 0, 1).toString() //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

另外一个函数是valueOf(),这个方法的任务并未详细定义：如果存在任意原始值，它就默认将对象转换为表示它的原始值。对象是复合值，而且大多数对象无法真正表示一个原始值，数组、函数和正则表达式简单地继承了这个默认方法，调用这些类型的实例的的valueOf()方法简单地返回对象本身。日期类定义的valueOf()方法返回它的一个内部表示：1970年1月1日以来的毫秒数。

Die Codekopie lautet wie folgt:

var d = new Date(2015, 0, 1); //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

d.valueOf() //=>1420041600000

通过是用我们刚才讲解过的toString()和valueOf()方法，就可以做到对象到字符串和对象到数字的转换了。但在某些场景中，javascript执行了完全不同的对象到原始值的转换。这些特殊的场景在本节的最后会讲到。

javascript对象到字符串的转换经过了如下这些步奏

如果对象具有toString()方法，则调用这个方法。如果它返回一个原始值，javascript将这个值转换为字符串（如果本身不是字符串的话），并返回这个字符串结果。

如果对象没toString()方法，或者这个方法并不返回一个原始值，那么javascript会调用valueOf()方法。如果存在这个方法，则javascript调用它。如果返回值是原始值，javascript将责怪值转换为字符串。

9.变量声明。

在javascript程序中，使用一个变量之前应该先声明，变量是通过var来声明的，如下所示：

var i;

var sum;

也可以通过一个var关键字声明多个变量

var i,sun;

而且还可以将变量的初始值和变量声明和写在一起；

var message = "hello";

var i=0 ,j=0,k=0;

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. Zum Beispiel:

Die Codekopie lautet wie folgt:

for (var i = 0; i < 10; i++) log(i);

for (var i = 0, j = 10; i < 10, j = 100; i++, j--) console.log(i * j)

for (var p in o) console.log(p);

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. Zum Beispiel:

Die Codekopie lautet wie folgt:

var i=10;

i="ten";

10.变量作用域

一个变量的左右域（scope）是程序源代码中定义这个变量的区域，全局变量拥有全局作用域，在javascript代码中的任何地方都是定义。然而在函数内部声明变量只在函数体内有定义。他们是局部变量，作用是局部性的。函数参数也是局部变量，它们只在函数体内有定义。

在函数体内，局部变量的优先级高于同名的全局变量。如果在函数内声明一个局部变量或者函数参数中带有的变量和全局变量重名，那么全局变量就被局部变量所遮盖。

Die Codekopie lautet wie folgt:

var scope = "global"; //声明一个全局变量

function checkscope() {

var scope = "local"; //声明一个同名的局部变量

return scope;

}

checkscope(); //=>"local"

尽管在全局作用域编写代码时可以不写var语句，但声明局部变量时则必须使用var语句。

Die Codekopie lautet wie folgt:

scope = "global"; //声明一个全局变量,甚至不使用var来声明

function checkscope2() {

scope = "local"; //修改了全局变量

myscope = "local"; //这里显示式得声明了一个新的全局变量

return [scope, myscope]; //

}

checkscope2(); //=> ["local","local"]:产生了副作用

scope // =>"local"全局变量修改了

myscope //=> "local"全局命名空间搞乱了。

函数定义是可以嵌套的。由于每个函数都有它直接的作用域，因此会出现几个局部作用域嵌套的情况。

Die Codekopie lautet wie folgt:

var scope = "global scope"; //全局变量

function checkscope() {

var scope = "local scope"; //局部变量

function nested() {

var scope = "sested scope"; //嵌套作用域内的局部变量

return scope;

}

return nested();

}

checkscope() //=>"嵌套作用域" sested scope

ich. Function scope and declaration in advance

在一些类似c语言的编程语言中，花括号内的每一段代码都具有各自的左右域，而且变量在声明他们的代码之外是不可见的我们称之为块级作用域(block scope),而javascript中没有块级作用域，javascript取而代之的使用了函数作用域(function scope);变量在声明它们的函数体以及这个函数体嵌套的任意函数体内都是有意义的。

如下代码，在不同的位置定义了ijk，他们都在同一个作用域内，这三个变量在函数体内均有定义的。

Die Codekopie lautet wie folgt:

function test(o) {

var i = 0; //i在整个函数体内均是定义的

if (typeif o == "object") {

var j = 0; //j在函数体内是有定义的，不仅仅是在这个代码段内

for (var k = 0; k < 10; k++) { //k在函数体内是有定义的，不仅仅是在循环内

console.log(k); //输出数字0-9

}

console.log(k); //k已经定义，输出10

}

console.log(j); //j已经定义了，但可能没有初始化。

}

javascript的函数作用域是指在函数内声明的所有变量在函数体内始终是可见的。有意思的是，这意味这变量在声明之前甚至已经可用。javascript的这个特性被非正式的称为声明提前（hoisting），即javascript函数里声明的所有变量(但不涉及赋值)都被提前至函数整体的顶部。如下代码：

Die Codekopie lautet wie folgt:

var scope = "global";

function f() {

console.log (scope); //Output "undefined", not "global"

var scope = "local"; //变量在这里赋初始值，但变量本身在函数体内任何地方都是有定义的

console.log (scope); //Output "local"

你可能误以为函数的第一行会输出"global",因为代码还没有执行到var语句声明局部变量的地方。其实不然，由于函数作用域的特性模具部变量在整个函数体内始终有定义的，也就是说，在函数体内局部变量覆盖了同名全局变量。尽管如此，只有在程序执行到var语句的时候，局部变量才能正真的被赋值。

因此，上述的过程等价于：将函数内的变量声明"提前"至函数顶部，同时变量初始化留在原来的位置：

Die Codekopie lautet wie folgt:

function f() {

var scope; //在函数的顶部声明了局部变量

console.log (scope); //The variable exists, but its value is "undefined"

scope = "local"; //在这里将其初始化，并赋值

console.log (scope); //Here it has the value we expect

}

在具有块级作用域的编程语言中，在狭小的作用域里让变量声明和使用变量的代码尽可能靠近彼此，通常来说，这是一个非常不错的编程习惯。由于在javascript中没有块级作用域，因此一些程序员特意将变量声明放在函数体顶部，而不是将声明放在靠近使用变量之处。这种做法使得他们的源代码非常清晰地反映了真实的变量作用域。

ii作为属性的变量

当声明一个javascript全局变量时面试及上是定义了全局对象的一个属性。见本文第三节。

当使用var声明一个变量时，创建的这个属性是不可配置的。见第六章第7节。也就是说这个变量无法通过delete运算符删除。可能你已经注意到了，如果你没有使用严格模式并给一个未声明的变量赋值的话。javascript会自动创建一个全局变量。以这种方式创建变量是全局对象正常的可配置属性。可以删除它们。

Die Codekopie lautet wie folgt:

var truevar = 1; //声明一耳光不可删除的全局变量

fakevar = 2; //创建全局对象的一个可删除的属性

this.fakevar2 = 3; //同上

delete truevar // =>false 变量并没有删除

delete fakevar //=>true 变量被删除

delete this.fakevar2 //=>true 变量被删除

javascript全局变量是全局对象的属性，这是在ECMAScript规范中强制规定的。对于局部变量则没有此规定，但我们可以想象得到，局部变量当做跟函数调用相关的某个对象的属性。ECMAScript3规范称对象为“调用对象”（call object）,ECMAScript5规定范称为“声明上下文对象”（declarative environment record）。javascript可以允许使用this关键字引用全局对象，却没有方法可以引用局部变量中存放的对象。这种存放局部变量的对象的特有性质，是一种对我们不可见的内部实现。然而，这些局部变量对象存在的观念是非常重要的。

iii作用域链

javascript是基于词法作用域的语言：通过阅读包含变量定义在内的舒航源码就能知道变量的作用域。

全局变量在程序中始终是都是有定义的。局部变量在声明它的函数体内以及其所嵌套的函数内始终是有定义的。