Weniger beliebte Wissenspunkte zu JavaScript

Native Funktionen

Häufig verwendete native Funktionen

String()

Number()

Boolean()

Array()

Object()

Function()

RegExp()

Date()

　 Error()

　Symbol()

　 Interne Eigenschaften [Klasse]

　 Alletypeof Objekte mit einem Rückgabewert von Objekt enthalten ein internes Attribut [Klasse], Dieses Attribut kann nicht direkt Zugriff, im Allgemeinen über Object.prototype.toString(..) .

Zum Beispiel :

Object.prototype.toString.call([1,2,3]);

// " [ object Array]"

Basistypwert

　Object.prototype.toString.call(null);

// "[object Null] "

　　

Packaging Object Wrapper

　　　Da der Basistypwert nicht über .length und .toString verfügt () Solche Eigenschaften und Methoden.

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　Mit neuem

Keyword)　var a = "abc"; var b = new String (a);　var c = Object(a);

Dies ist im Allgemeinen nicht der Fall Es wird empfohlen, die gekapselte Funktion direkt zu verwenden

Entpacken

Um grundlegende Typwerte in Objekten zu kapseln, können Sie

valueOf verwenden ()

Funktion.

var a = new String("abc");

var b = new Number(42);var c = new Boolean(true);

a.valueOf(); // "abc"

b.valueOf(); // 42

c.valueOf(); // wahr

　 Native Funktion als Konstruktor

　　Array(..)

　　var a = new Array(1,2,3); 🎜>

a; // [1,2,3] var b = [1,2,3]

b; // [1,2,3]

Konstruktor

Array(..),

muss nicht das Schlüsselwort

new haben, es wird automatisch hinzugefügt, wenn

nicht vorhanden ist enthalten Wenn der

Array-Konstruktor nur einen Parameter akzeptiert, ist der Parameter die voreingestellte Länge des Arrays und nicht ein Element im Array. var a = new Array(3); a.length; // 3 a;

Nicht Erstellen und verwenden Sie leere Zellenarrays

　 Object(..) , Function(..) ,

und

RegExp(..)

Sofern nicht unbedingt erforderlich, verwenden Sie nicht

Object(..) / Function(..)/ RegExp(..) Date(..)

und

Fehler(..)

　 Die Erstellungszeit muss new Date() verwenden. wird hauptsächlich verwendet, um den aktuellen Unix--Zeitstempel Datum zu erhalten .new() und rufen Sie es dann über getTime() im Datumsobjekt ab.

　 Erstellen Sie ein Fehlerobjekt (Fehlerobjekt) Hauptsächlich, um den aktuellen laufenden Kontext zu erhalten.

　Symbol(..)

　 Grunddatentyp —— Symbol. Symbole haben eindeutige Sonderwerte. Wenn Sie sie zum Benennen von Attributen verwenden, führt dies nicht leicht zu doppelten Namen.

Statische Attributform von Symbol , Symbol.create, Symbol.iterator

obj[Sybol.iterator] = function() {/*..*/}

Verwenden Sie den nativen Konstruktor Symbol(..) , um Symbole anzupassen. Sie können keine neuen Schlüsselwort, sonst wird ein Fehler gemeldet.

var mysym = Symbol("mein eigenes Symbol");

mysym; // Symbol(mein eigenes Symbol)

mysym.toString(); / "Symbol(mein eigenes Symbol)"

typeof mysym; // "symbol"

var a = { };

a[mysym ] = "foobar";

Object.getOwnPropertySymbols(a);

// [Symbol(mein eigenes Symbol)]

Prototyptyp

Der native Konstruktor verfügt über ein eigenes .prototype-Objekt wie: Array.prototype,

String.prototype.

>

　　　　String#indexOf(..)

　　　　 Finden Sie die Position der angegebenen Zeichenfolge in der Zeichenfolge.

　　　String#charAt(..)

　　　 Holen Sie sich das Zeichen an der angegebenen Position in der Zeichenfolge

　　　String#substr(.. ),String #substring(..)

und String# segment(..)

Ruft den angegebenen Teil der Zeichenfolge ab

String#toUpperCase()

und String#toLowerCase()

　String in Groß- und Kleinbuchstaben umwandeln

String #trim()

　　　　　　　　　　　　　　　　　　　　　　　　　　　　 will be returned as a new string 　　

　　　　　

　　 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　到　　　　　　　　〉

🎜> Typkonvertierung von Werten

Konvertieren eines Werts von Eins Typ zu einem anderen, dies ist der gezeigte Fall,

Implizite Fälle sind normalerweise Umwandlungen.

Typkonvertierung in JavaScript

gibt immer einen skalaren Basistyp zurück.

　Abstrakte Wertoperation　ToStringAbstrakte OperationToString , die für die Verarbeitung von Nicht-Werten verantwortlich ist -strings Umwandlung in einen String

Die Standardmethode

toString()

des Arrays wurde neu definiert, um alle Einheiten zu stringisieren

, bevor sie miteinander verkettet werden.

var a = [1,2,3];

a.toString(); // "1,2,3" JSONString-Ersatz,

　　　　 JSON.stringify(..) wird automatisch angezeigt, wenn im Objekt auf undefiniert, Funktion und Symbol gestoßen wird wird ignoriert und null wird im Array zurückgegeben.

Zum Beispiel:

JSON.stringify(undefiniert); // undefiniert

JSON.stringify(function(){}) ; // undefiniert

　　　　　　JSON.stringify(

　　　　[1,undefiniert,function(){},4]

　　); // "[1,null,null , 4]"

　　　　　JSON.stringify(

　　　{a:2,b:function(){}}

　　); // "{"a":2 } "

　toJSON() sollte einen geeigneten Wert zurückgeben, der von jedem Typ sein kann, und dann JSON.stringify(. . ) Ausrichtung zur Stringifizierung.

　ToNumber

Manchmal müssen Sie nicht numerische Werte als Zahlen verwenden, z. B. bei mathematischen Operationen.

true wird in 1 umgewandelt, false wird in 0, undefiniert wird in NaN

　 null

wird in 0 umgewandelt

　　　　Um den Wert in den entsprechenden Grundtyp umzuwandeln, prüft die abstrakte Operation ToPrimitive, zunächst, ob der Wert einen valueOf() Methode, und wenn ja, verwenden Sie sie. Der Wert wird umgewandelt. Wenn nicht, verwenden Sie den Rückgabewert von toString()

, um eine erzwungene Typkonvertierung durchzuführen. Wenn weder

valueOf() noch toString() den Wert zurückgeben, tritt ein TypeError -Fehler auf. ToBoolean

Falscher Wert

:

Werte können in die folgenden zwei Kategorien unterteilt werden.

1.

kann auf den Wert von

false 2.

Andere

( ist ein leichter Typ, der in den Wert von true) konvertiert wird. 　　　　 Das Folgende sind falsche Werte

undefiniert

null

false

+0,-0

und

NaN""

　　　 Falsches Wertobjekt: In einigen spezifischen Fällen basiert der Browser auf der regulären

JavaScript

-Syntax erstellt einige Fremdwerte, dies sind das „False Value Object“　　　True Value

　 Ein wahrer Wert ist ein Wert außerhalb der Liste der falschen Werte

Explizite Umwandlung

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ccoleg in einer Zeichenfolge und einer Zahl

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 Banks Hand� 　　 Die Display-Cast-Konvertierung zwischen String und Zahl erfolgt durch String(..) Explizite Cast between 🎜>var b = String(a);var c = "3.14";

var d = Number(c);b; / "42"

d: // 3.14

　　

Es gibt andere Möglichkeiten, eine Anzeigekonvertierung zwischen Zeichenfolgen und Zahlen zu erreichen

var a = 42 ;

var b = a.toString();

var c = "3.14";

var d = +c;b; "42"

d: // 3.14

　 Datumsanzeige in Zahl umwandeln

Unärer Operator

+ besteht darin, ein Datumsobjekt

(Datum)

in eine Zahl umzuwandeln.

var timestamp = +new Date(); Analysieren Sie die numerische Zeichenfolge explizit. Analysieren Sie die numerische Zeichenfolge Numbers und Das Rückgabeergebnis der Umwandlung einer Zeichenfolge in eine Zahl sind beide Zahlen.

Zum Beispiel:

var a = "42";

var b = "42px";

Zahl (a); // 42

parseInt(a); // 42

Number(b); // NaN

parseInt(b);

Durch das Parsen kann die Zeichenfolge nicht numerische Zeichen enthalten. Das Parsen erfolgt in der Reihenfolge von links nach rechts. Wenn

auf ein nicht numerisches Zeichen stößt, wird es gestoppt.

　　　　 parseInt(..)

ist für Zeichenfolgen, wie

parseInt(..)

Es gibt keine Möglichkeit, Zahlen und andere Arten von zu übergeben Parameter Verwenden Sie , um die Konvertierung in einen booleschen Wert anzuzeigen.

ToBoolean ist explizit. ToBoolean obligatorisch Typkonvertierung:

var a = "0";

var b = [];

var c = {}; var d = "";

var e = 0;

var f = null;

var g;

Boolean(a); // true

Boolean(b); // true

Boolean(c); // true

Boolea(d); // false

Boolea(e); // false

Boolea(f); // false

Boolea(g); / false

　　Unärer Operator! Wandeln Sie den Wert explizit in einen booleschen Wert um.

var a = "0";

var b = [];

var c = {};

var d = "";

var e = 0;

var f = null;

var g;

!!a; // wahr

!!b; // wahr

!!c; // wahr

!!d; // false

!!e; // false

!!f; // false

!!g; >

Implizite Umwandlung

Implizit vereinfacht

Implizite Umwandlung zwischen Zeichenfolgen und Zahlen

Der +-Operator kann sowohl für die Addition von Zahlen als auch für die Verkettung von Zeichenfolgen verwendet werden.

var a = "42";

var b = "0";

var c= 42;

var d = 0 ;

a + b; // "42"

c + d; // 42

Objekts - Die Operation ähnelt + ;

var a = [3];

var b = [1];

a - b ; // 2

Implizite Umwandlung von boolescher Zahl in Zahl

implizite Umwandlung in booleschen Wert

Die folgenden Situationen führen zu einer impliziten Umwandlungskonvertierung

1.

2.für(..;...;..)

Bedingter Urteilsausdruck in der Aussage(Der Zweite )

3.while(..)

und do..while(..) Bedingungen in der Schleife Beurteilungsausdruck .

4.

? : Bedingter Ausdruck in

5.

Logischer Operator|| (Logisches ODER) und ( logisches UND ) Der Operand auf der linken Seite von (als bedingter Ausdruck)

　　 ||.

und &&

|| Es muss vom booleschen Typ sein, aber der Wert eines der beiden Operanden

var a = 42;var b = "abc";var c = null;

a || b; // 42

a && b; // "abc"

c || // "abc"

null

wenn für

||

Wenn das bedingte Beurteilungsergebnis

wahr ist

, wird der Wert der ersten Zahl zurückgegeben werden. Wenn false ist, wird der zweite Operand zurückgegeben. && ist das Gegenteil.

Das Folgende ist eine sehr häufige

||.

function foo(a,b){a = a ||. "hello";b = b || "world"; console.log(a + " " + b );}

foo(); // "Hallo Welt"

foo("yeah","yeah"); // "yeah yeah"

Symboldarstellung

Entspannte Gleichheit und strikte Gleichheit

　　　　 "== erlaubt Umwandlungen in Gleichheitsvergleichen, während === nicht zulässt "

　Abstrakte Gleichheit

Es gibt ein paar Unkonventionelle zu beachten

NaN ist nicht gleich NaN

+0 ist gleich -0

Relaxierte Ungleichheit != ist Das Gegenteil von == ist dasselbe wie !==

Zeichengleichheitsvergleich zwischen Zeichenfolgen und Zahlen

1.Wenn Type(x) eine Zahl ist, Type ( y) eine Zeichenfolge ist, wird das Ergebnis von x== ToNumber(y)

zurückgegeben.

2.Wenn Type(x) eine Zeichenfolge ist, Type(y) eine Zahl ist, wird das Ergebnis von ToNumber(x)== y zurückgegeben.

Gleichheitsvergleich zwischen anderen Typen und booleschen Typen

== == Der fehleranfälligste Ort ist wahr und false und anderen Typen

var a = "42";

var b = true;

a == b; // false

1.

Wenn Type(x) ein boolescher Typ ist, Geben Sie dann das Ergebnis von ToNumber(x) == y

2 zurück.

IfType(y) ist ein boolescher Typ, dann wird das Ergebnis von x == ToNumber(y)

zurückgegeben. Zuerst:

var x = true;

var y = "42";

x == y; // false

Umgekehrt

var x = "42";

var y = false;

x == y; // false

　　　　 null

und undefiniert

==

beinhaltet auch Einsiedlerabgüsse. 1.Wenn x

null ist, ist y

undefiniert , dann ist das Ergebnis wahr

2.Wenn x undefiniert ist, ist y null, Das Ergebnis istwahr

var a == null;

var b;

a == b; // wahr

a == null; // wahr

b == null; // wahr

a == falsch

b == false; // false

a == "" ; // false

b == "" // false

a == 0; false

b == 0; // false

　　Gleichheitsvergleich zwischen Objekten und Nichtobjekten

Über Objekte und (Objekt/Funktion/ Array) und Skalarprimitive (String/Number/Boolean Vergleich zwischen Werten ​​).

1.Wenn Type(x) eine Zeichenfolge oder Zahl ist, type(y) ist ein Objekt, gibt das Ergebnis von x == ToPrimitive(y)

2.If Type(x) ist ein Objekt, Type(y) ist eine Zeichenfolge oder Zahl, dann return

　　ToPromitive( x) Das Ergebnis von == y

.

var a = 42;

var b = [42];

a == b; // true

var a = "abc";

var b = Object(a); // new String(a)

Same

a === b; // false

a == b; // true

a == b

Das Ergebnis ist true, sollte b wandelt über ToPromitive , um und gibt den Basistypwert "abc" zurück, gleich a .

Vergleich falscher Gleichwerte

Das Folgende sind regelmäßige und unkonventionelle Vergleiche

"0" = = null; // false

"0" == undefiniert; // false

"0" == false --

Halo!

"0" == NaN; // false

"0" == 0; // true

"0" == "" / / false

false == null; // false

false == undefiniert; // false

false == NaN;

false == 0; // true --

Halo!

false == "" // true -- Halo!

false == [] // wahr – Halo!

false == {} // false

"" == null; // false

"" == undefiniert; // false

"" == NaN; // false

"" == 0; // true -- Halo!

"" == []; // true -- Halo!

"" == {}; // false

0 == null; // false

0 == undefiniert; // false

0 == NaN; // false

0 == [] -- Halo!

0 == {}; false

Weil es sich um falsch positive Ergebnisse handelt.

　　　Extremfälle

　　　　[] == ![] // true

 　　Erzwungene Typkonvertierung boolescher Werte [] == ![] wird zu [] == false,

　　　　 2 == [2]

　　　 = = [null] ; //true

42 == "43" // false

"foo" == 42; // false

"true" = '"" // false

42 == "42" // true

"foo" == ["foo"] // true

Implizite Umwandlung sicher verwenden

1.Wenn die Werte auf beiden Seiten wahr sind Oder falsch, Niemals == verwenden.

2.Wenn auf beiden Seiten [] ,"" oder 0 , versuchen Sie, == nicht zu verwenden. Zu diesem Zeitpunkt ist es am besten, dies zu tun Verwenden Sie === , um eine erzwungene Typkonvertierung zu vermeiden.

Abstrakter Beziehungsvergleich

Beide Seiten sind String-Vergleiche

var a = ["42"];

var b = ["043"];

a < b; > und

b

werden nicht in Zahlen umgewandelt, da ToPrimitive eine Zeichenfolge zurückgibt und vergleicht die beiden Zeichenfolgen "42 "

und

"043" , da "0" alphabetisch kleiner ist als "4", also ist das Endergebnis

falsch.

Ähnlich

var a = [4,2];var b = [0,4,3];

a < b;

a wird in "4,2" umgewandelt, b wird in umgewandelt „ 0,4,3“ Derselbe Stil wird in alphabetischer Reihenfolge verglichen.

var a = {b: 42};

var b = {b:43};

a < b ; // false

a ist [Objekt Objekt], b ist auch [Objekt Objekt] also in alphabetischer Reihenfolge

a < b ist nicht wahr.

Das folgende Beispiel

var a = {b: 42};

var b = {b:43};

a < // false

a == b; // false

a <= b; // wahr

a >= b; // wahr

Das obige ist der detaillierte Inhalt vonWeniger beliebte Wissenspunkte zu JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!