Zusammenfassung der Konvertierungsbeispiele vom Bedienertyp in JavaScript

Lassen Sie uns zunächst einige Fragen stellen! Um sich zu vereinen, mische ich diese Fragen nicht. In Interviewfragen mische ich diese Fragen oft, was Sie verwirrter macht. Um es bequemer für die Demonstration zu machen, habe ich hier einige Fragen in Modulen geschrieben, damit Sie es lesen können!

Implizite Umwandlung von Bedienungsketten

Multiplikation

 console.dir ("--------------------------"); console.dir (5*"5"); console.dir (5*"a"); console.dir (5*nan); console.dir (5*null); console.dir (5*undefiniert); console.dir (5*5); console.dir("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Division

 console.dir ("----------------------"); console.dir (5/"5"); console.dir (5/"a"); console.dir (5/nan); console.dir (5/null); console.dir (null/5); console.dir (5/undefiniert); console.dir (5/5); console.dir (5/0); console.dir (0/5); console.dir (0/0); console.dir ("------------------------"); console.dir ("-----------------------------");

Nehmen Sie den Rest und finden Sie das Modell

 console.dir ("---------------------------"); console.dir (16%"5"); console.dir (5%"a"); console.dir (5%Nan); console.dir (5%null); console.dir (null%5); console.dir (5%undefiniert); console.dir (5%5); console.dir (5%0); console.dir (0%5); console.dir (0%0); console.dir ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Zusatz

 console.dir ("-----------------------"); console.dir (16+ "5"); console.dir (5+ "a"); console.dir (5+nan); console.dir (5+null); console.dir (5+undefiniert); console.dir (5+5); console.dir ("Die Summe von zwei Zahlen ist"+5+5); console.dir ("Die Summe von zwei Zahlen ist"+(5+5)); console.dir("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Subtraktion

 console.dir ("----------------------"); console.dir (16- "5"); console.dir (5- "a"); console.dir (5-nan); console.dir (5-null); console.dir (5 -undefined); console.dir (5-5); console.dir (5-fach); console.dir (5- "true); console.dir (5-" "); console.dir (" Der Unterschied zwischen zwei Zahlen ist "+5-5); Konsole.dir (" Der Unterschied zwischen zwei Zahlen ist "+(5-5)); console.dir (" ----------------- "); console.dir (". console.dir ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Relationale Operatoren

 console.dir ("--------------------"); console.dir (16> "5"); console.dir ("16"> "5"); console.dir (5 <"a"); console.dir (5> = nan); console.dir (5 <nan); console.dir (nan> = nan); console.dir (5> = null); console.dir (5> = undefiniert); console.dir (5> = 5); console.dir (5> = true); console.dir (5> = "true"); console.dir (5> = ""); console.dir ("Ziegel"> "Alphabet"); console.dir ("Ziegel"> "Alphabet"); console.dir ("----------------------");

Multiplikation

 console.dir (5*"5"); // 25 console.dir (5*"a"); // nan console.dir (5*nan); // nan console.dir (5*null); 0 console.dir (5*undefiniert); // nan console.dir (5*5); // 25

Lassen Sie uns über das Prinzip der implizite Umwandlung der Multiplikation sprechen:

1. Wenn die beiden Werte Zahlen sind, führen Sie Multiplikationsvorgänge direkt durch. (Ich glaube, jeder kann es tun, genau wie die Mathematik der Grundschule, und Sie sollten auf die Symbole der Zahlen achten). Wenn der Produktwert den numerischen Repräsentationsbereich von ECMascript überschreitet, geben Sie Unendlichkeit (positiv unendlich) oder -Infinity (negativ unendlich) zurück, die unendlich (positiv unendlich) oder unendlich) zurückkehren.

2. Wenn eine Zahl Nan ist, dann ist das Ergebnis NAN

3. Wenn die Unendlichkeit mit 0 multipliziert wird, ist das Ergebnis NAN

4. Wenn ein Bediener eine Zahl ist und der andere kein numerischer Wert ist, verwenden Sie zuerst die Funktion number (), um sie umzuwandeln und den konvertierten Wert mit der Zahl zu multiplizieren. Wenn das konvertierte Ergebnis NAN erscheint, ist das Ergebnis NAN.

Division

 Konsole. 0/5 ist 0 console.dir (5/undefiniert); // nan undefinierte Konvertiten mit Number () und das Ergebnis ist eine Nan -Konsole.

Sprechen wir über das implizite Konversionsprinzip der Teilung:

Ähnlich wie bei der Multiplikation ist das einzige weitere, dass 0/0 Ergebnis NAN ist

Nehmen Sie den Rest und finden Sie das Modell

Das häufigste, was Sie im Projekt verwenden müssen, ist, ungerade und sogar Zahlen zu finden. Wir verwenden oft eine Zahl mit 2, um den Restbetrag zu berechnen. Wenn das Ergebnis 0 ist, ist die Zahl eine gleichmäßige Zahl, und wenn das Ergebnis 1 ist, ist die Nummer eine ungerade Zahl.

Schauen Sie sich das obige Thema an:

 console.dir (16%"5"); // 1 Konvertieren Sie die Zeichenfolge 5 bis 5 über Nummer () und berechnen Sie dann die verbleibende Konsole.dir (5%"A"); // nan console.dir (5%nan); // nan console.dir (5%null); // nan konvertieren null über number (), das Ergebnis ist 0 und berechnen dann 5%0, das Ergebnis ist Nan -Konsole.dir (Null%5); // 0 Die gleichen wie über 0%5, das Ergebnis ist 0 Konsole.Dir (5%undefinierte); // Nan Console.dir (5%5); // 0 console.dir (5%0); // Nan Console.dir (0%5); // 0 console.dir (0%0); // nanconsole.dir (unendlich%unendlich); // nanconsole.dir (5%unendlich); // 5 console.dir (Infinity%5); // nan

Lassen Sie uns über das Prinzip der implizite Umwandlung von Residuen sprechen:

Lassen Sie mich wie Multiplikation über etwas Besonderes sprechen! Wir alle kennen die Konzepte von Dividenden und Divisoren, die wir in der Grundschule gelernt haben.

1. Die Dividende ist unendlich und die Dividende ist ein endlicher Wert, daher ist das Ergebnis NAN

2. Der Divisor ist ein endlicher Wert, und der Divisor ist 0, dann ist das Ergebnis Nan

3. Infinity%Infinity Ergebnis ist NAN

4. Die Dividende ist ein endlicher Wert, die Dividende ist ein unendlicher Wert und das Ergebnis ist ein Divisor.

5. geteilte Zahl ist 0, das Ergebnis ist 0

Subtraktion

Schauen Sie sich das obige Beispiel an!

 console.dir (16- "5"); // 11 console.dir (5- "a"); // nan console.dir (5-nan); // nan console.dir (5-null); // 5 console.dir (5-lindefined); // nan console.dir (5-5); // 0/ 0/ 0/0. 0/0/0. 0/0. 0/ 0/ 0/0. 0/0/0/0/0. 0/0. (5-True); console.dir (5- "true"); // nan console.dir (5-""); // 5 console.dir (5-infinity); //-Infinity Console.dir (Infinity-Infinity); // Nan-Konsole.dir ("Der Unterschied zwischen zwei Zahlen"+5-5). Zahlen sind 0

Lassen Sie uns über das Prinzip der implizite Umwandlung der Subtraktion sprechen:

Genau wie oben werde ich nicht über dasselbe sprechen, ich werde über die einzigartige Subtraktion sprechen.

1. Infinity-Infinity-Ergebnis ist NAN

2. -Infinity -Infinity -Ergebnis ist -Infinity

3.. Das Ergebnis einer Zahl ohne Unendlichkeit ist - Unendlichkeit

4. Infinity-(-Infinity) Das Ergebnis ist Unendlichkeit

5. Wenn es sich bei dem Operand um ein Objekt handelt, wird die Objektwert -Methode aufgerufen. Wenn das Ergebnis NAN ist, ist das Ergebnis NAN. Wenn es keine Mehrwertmethode gibt, rufen Sie die Methode toString () auf und konvertieren Sie die resultierende Zeichenfolge in einen numerischen Wert.

Relationale Operatoren

Relationale Operatoren geben einheitlich wahr oder falsch zurück

 console.dir (16> "5"); // True Console.dir ("16"> "5"); // falsche Konsole.dir (5 <"a"); // falsche Konsole.dir (5> = nan); // falsche Konsole.dir (5 <nan); // false console.dir (nan> = nan); // false console.dir (5> = null); console.dir (5> = undefined); // false console.dir (5> = 5); // true console.dir (5> = true); // True Console.dir (5> = undefiniert); // falsche Konsole.dir (5> = 5); // Trusole.dir (5> = True); console.dir (5> = ""); // True Console.dir ("Brick"> "Alphabet"); // Falsch der Zeichenfolge -Coding -Wert von B ist 66, während die String -Codierung von A 97 ist. Daher ist falscher Konsole.

Sprechen wir über das implizite Konversionsprinzip von relationalen Operatoren:

Es ist immer noch dasselbe wie oben, ich werde nicht dasselbe sagen.

Wenn es sich bei den beiden verglichenen Zahlen um Zeichenfolgen handelt, wird die String -codierte Werte, die der Zeichenfolge entsprechen, verglichen.

Zusatzbetrieb

Der Grund, warum ich schließlich sagte, dass die implizite Umwandlung von Additionsoperationen ist, dass sich die implizite Umwandlung von Additionsoperationen von den vorherigen unterscheidet. Alle früheren Operatorsymbole, solange eine Zahl ist, verwendet der andere auch Number (), um die Zahlen standardmäßig zu konvertieren. Der Additionsbetrieb ist unterschiedlich. Solange einer der Additionsvorgänge eine Zeichenfolge ist, wird der andere auch in eine Zeichenfolge umgewandelt und dann wird das String -Spleißen durchgeführt!

 console.dir (16+ "5"); // 156 console.dir (5+ "a"); // 5a console.dir (5+nan); // nan console.dir (5+null); // 5 console console.dir (5+5); // 10 console.dir ("Summe von zwei Zahlen ist"+5+5); // Summe von zwei Zahlen ist 55 Konsole.dir ("Summe von zwei Zahlen ist"+(5+5); // Summe von zwei Zahlen ist 10 IS 10

Sprechen wir über das implizite Konvertierungsprinzip von Additionsbetreibern:

Eines ist eine Zeichenfolge, und der andere wird auch zum Spleißen in eine Schnur umgewandelt. Wenn einer eine Zeichenfolge ist und der andere null oder nicht definiert ist, ruft hinzu, null oder undefiniert die String () -Methode, um die Zeichenfolge "Null" oder "undefiniert" zu erhalten und sie dann zu spleißen.

2. Wenn eine Zahl mit Null oder undefiniertem hinzugefügt wird, wird Null oder undefiniert in die Nummer () konvertiert und dann hinzugefügt.

3. Die verbleibenden Prinzipien ähneln anderen, daher werde ich nicht viel sagen.

Biequal implizite Konvertierung

Führen Sie den folgenden Code einmal aus, und ich glaube, Sie werden ihn natürlich verstehen ~

 var a; console.dir (0 == false); // trueconsole.dir (1 == true); // trueconsole.dir (2 == {valueof: function () {return 2}}); // trueconsole.dir (a == nan); // FALSECONSOL.DIR (NANN == Nan == nan); undefiniert); // falseconsole.dir (1 == undefined); // falseconsole.dir (2 == {toString: function () {return 2}}); // TrueConsole.dir (undefined == null); // Trueconsole.dir (null == 1= 1);/// faleconsole. {{{uLldir (null == 1= 1= 1);/// faleconsole. {{{uLl. toString: function () {return 1}, valueof: function () {return []}} == 1); // trueconsole.dir (1 == "1"); // Trueconsole.dir (1 == "1"); // false