Beispiel für einen impliziten Konvertierungsmechanismus des doppelten Gleichheitszeichens in Javascript

Es gibt zwei Arten von Gleichheitszeichen in Javascript: das doppelte Gleichheitszeichen (==) und das dreifache Gleichheitszeichen (===). Das doppelte Gleichheitszeichen (==) zeigt Wertgleichheit an, während das dreifache Gleichheitszeichen (===) strikte Gleichheit anzeigt (ob die Werte und Typen vollständig gleich sind).

Es gibt also einiges an gesundem Menschenverstand:

1. Für Grundtypen wie Zeichenfolge, Zahl usw. gibt es einen Unterschied zwischen == und ===
1) Vergleich zwischen verschiedenen Typen, == vergleicht „in denselben Typ konvertierte Werte“, um zu sehen, ob die „Werte“ gleich sind, === wenn die Typen unterschiedlich sind, ist das Ergebnis ungleich
2) Vergleich des gleichen Typs, direkter Vergleich von „Wert“, das Ergebnis ist das gleiche

2. Für erweiterte Typen wie Array, Object sind == und === nicht unterscheidbar
Führen Sie einen „Zeigeradressen“-Vergleich durch

3. Es gibt einen Unterschied zwischen Basistypen und erweiterten Typen, == und ===
1) Konvertieren Sie für == den erweiterten Typ in einen Basistyp und führen Sie ihn aus „Wert“-Vergleich
2) Da die Typen unterschiedlich sind, = ==Das Ergebnis ist falsch

Mit anderen Worten, das doppelte Gleichheitszeichen (==) führt Typkonvertierung während des Betriebs, während das dreifache Gleichheitszeichen (== =) Nr.

Zum Beispiel:

alert('55' == 55); //true
alert('55' === 55); //false

Fünf grundlegende

Datentypen in Javascript-Sprache (Originalwert, auch einfacher Datentyp genannt) : Das heißt, Undefiniert, Null, Boolean, Zahl und String-Typ . Da diese primitiven Typen einen festen Platz einnehmen, können sie in einem kleineren Speicherbereich – dem Stapel – gespeichert werden. Dieser Speicher erleichtert das schnelle Nachschlagen des Werts der Variablen. (Einzelheiten finden Sie unter: http://www.w3school.com.cn/js/pro_js_value.asp)

Der implizite Konvertierungsmechanismus, der das doppelte Gleichheitszeichen (==) in Javascript verwendet, um Gleichheit zu bestimmen:

1, wenn beide Seiten einfache Typen sind:

1,1, beide Seiten sind einfache Typen und die Typen sind gleich, dann vergleichen Sie direkt.

console.log(1==1); //true
console.log("1"=="1"); //true
console.log(false==false); //true
console.log(null==null); //true
console.log(undefined==undefined); //true

1.2. Beide Seiten sind einfache Typen. Wenn die Typen unterschiedlich sind, werden sie zuerst in einen numerischen Vergleich umgewandelt (Boolean hat nur zwei Werte: true==1, false==0; null und undefiniert sind gleich;

StringZahl ist gleich numerischer Wert, leere Zeichenfolge „“==0;)

console.log(1==true); //true
console.log(0==false); //true
console.log(1=="1"); //true
console.log(0==""); //true
console.log(0==null); //false
console.log(0==undefined); //false
console.log(null==undefined); //true

2, wenn eine Seite ein einfacher Typ ist und die andere Seite einen Referenztyp (erweiterter Typ), dann werden erweiterte Typen vor dem Vergleich implizit in einfache Typen konvertiert.

console.log(Object==Object); //true
console.log(Object=={}); //false
console.log(0=={}); //false
console.log(0==[]); //true
console.log(Array==Array); //true
console.log(Object==Array); //false

3. Wenn beide Seiten Referenztypen (erweiterte Typen) sind, wird ein „Zeigeradressen“-Vergleich durchgeführt.

Wichtige Punkte – toString() und valueOf()

Der erste Eindruck, den viele Leute haben, wenn sie diese beiden Methoden sehen, ist, dass die toString()-Methode ein Objekt in einen String konvertiert und die valueOf Die Methode wandelt es in einen String um. Konvertiert ein Objekt in einen numerischen Wert.

Diese Idee ist sehr einseitig:

var obj={
    name:"熊仔其人",
    getName:function(){ return $(this).name; }
};

console.log(obj.toString()); //[object Object]

Definieren Sie ein obj-Objekt und rufen Sie seine toString-Methode auf. Der Rückgabewert ist [obj Object ]. Es wurde festgestellt, dass der Wert keine Zeichenfolgendarstellung seines Inhalts zurückgibt, wie wir dachten.

var arr=[1,2,3];
console.log(arr.valueOf()); //(3) [1, 2, 3]

Definieren Sie ein Array arr und rufen Sie dessen valueOf-Methode auf. Der Rückgabewert ist [1, 2, 3]. Wir stellen fest, dass der

numerische Typ nicht wie erwartet zurückgegeben wird. äußern.

Tatsächlich ist das eigentliche Verständnis folgendes: Durch Aufrufen der toString()-Methode des Objekts kann das Objekt in einen String konvertiert werden. Wenn Sie es jedoch in einen String konvertieren möchten, müssen Sie nicht unbedingt toString aufrufen Verfahren.

Schauen wir uns den Code unten noch einmal an.

var obj= { };     
obj.valueOf=function(){ return 1; }
obj.toString=function(){ return 2; }
console.log(obj==1);    //truevar obj2= { };     
obj2.valueOf=function(){ return 2; }
obj2.toString=function(){ return 1; }
console.log(obj2==1);    //false                        
var obj3={ };
obj3.valueOf=function(){ return []; }
obj3.toString=function(){ return 1; }
console.log(obj3==1);    //true

Im obigen Code haben wir ein Objekt obj, obj2 definiert und die Rückgabewerte der Methoden valueOf und toString definiert. Durch Vergleichen mit 1 auf Gleichheit haben wir festgestellt, dass die Methode valueOf ist wurde zuerst aufgerufen.

Definiert dann ein Objekt obj3, definiert den Rückgabewert der Methoden valueOf und toString und vergleicht ihn mit 1, um festzustellen, dass es die Methode toString aufruft.

Dann schauen wir uns den folgenden Code an:

var obj= { };     
obj.valueOf=function(){ return 'a'; }
obj.toString=function(){ return 2; }
console.log(obj=='a');    //truevar obj2= { };     
obj2.valueOf=function(){ return 'b'; }
obj2.toString=function(){ return 'a'; }
console.log(obj2=='a');    //false

Im obigen Code 2 ist ein Objekt obj definiert. Durch Vergleich mit der Zeichenfolge „a“ wird festgestellt, dass Es ruft die valueOf-Methode auf.

Dann gibt der Vergleich zwischen Objekt obj2 und 'a' false zurück und es wird festgestellt, dass die toString-Methode nicht aufgerufen wird.

Daraus können wir die Schlussfolgerung ziehen:

Wenn das Objekt in einen einfachen Typ konvertiert wird, wird zuerst die valueOf-Methode aufgerufen, wenn sie mit verglichen werden kann Ein einfacher Wert wird direkt verglichen. Die toString-Methode wird zu diesem Zeitpunkt nicht mehr aufgerufen. Wenn die valueOf-Methode nach dem Aufruf der valueOf-Methode nicht mit einem einfachen Wert verglichen werden kann, wird die toString-Methode erneut aufgerufen, um schließlich das Vergleichsergebnis zu erhalten.

Zu beachten ist jedoch, dass das Date-Objekt die oben genannten Regeln nicht erfüllt. Die Methoden toString und valueOf des Date-Objekts wurden neu definiert und die toString-Methode wird von aufgerufen Standard.

Das obige ist der detaillierte Inhalt vonBeispiel für einen impliziten Konvertierungsmechanismus des doppelten Gleichheitszeichens in Javascript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!