Es gibt zwei Möglichkeiten, Gleichheitsbeziehungen in Javascript zu beurteilen: 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). Dieser Artikel stellt Ihnen hauptsächlich den impliziten Konvertierungsmechanismus mit doppeltem Gleichheitszeichen (==) in JavaScript vor. Er ist sehr gut und hat Referenzwert. Ich hoffe, er kann jedem helfen.
Es gibt also einiges an gesundem Menschenverstand:
1 Für Grundtypen wie Zeichenfolge und Zahl gibt es einen Unterschied zwischen == und ===
1) Zwischen verschiedenen Typen vergleichen, == „in denselben Typ konvertierte Werte“ vergleichen, um zu sehen, ob die „Werte“ gleich sind, === wenn die Typen unterschiedlich sind, ist das Ergebnis ungleich
2) Vergleichen Sie denselben Typ und führen Sie direkt „Wert“ aus. „Vergleichen, die Ergebnisse sind die gleichen
2. Bei erweiterten Typen wie Array und Object gibt es keinen Unterschied zwischen == und ===
„Zeigeradressen“-Vergleich durchführen
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 einen „Wert“-Vergleich durch
2 ) Da die Typen unterschiedlich sind, ist das Ergebnis === falsch
Mit anderen Worten, das doppelte Gleichheitszeichen (==) wird ausgeführt Typkonvertierung während des Betriebs, das dreifache Gleichheitszeichen (===) jedoch nicht.
Zum Beispiel:
alert('55' == 55); //true
alert('55' === 55); //falseDie fünf grundlegenden Datentypen (primitive Werte, auch einfache Datentypen genannt) in der Javascript-Sprache: Undefiniert, Null, Boolean, Zahl und Zeichenfolge. Da diese primitiven Typen einen festen Platz einnehmen, können sie in einem kleineren Speicherbereich – dem Stapel – gespeichert werden. Eine solche Speicherung erleichtert die schnelle Suche nach Variablenwerten.
Der implizite Konvertierungsmechanismus unter Verwendung des doppelten Gleichheitszeichens (==) in Javascript zur Bestimmung der Gleichheit:
1, wenn beide Seiten einfache Typen sind:
1,1, wenn beide Seiten einfache Typen sind und die Typen gleich sind, werden sie direkt verglichen.
console.log(1==1); //true
console.log("1"=="1"); //true
console.log(false==false); //true
console.log(null==null); //true
console.log(undefined==undefined); //true1.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; Zeichenkettennummern sind gleich numerischen Werten, 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 Typ) wird der erweiterte Typ implizit in einfache Typen konvertiert und erneut verglichen.
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); //false3. 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, rufen Sie seine valueOf-Methode auf, der Rückgabewert ist [1, 2, 3] und stellen Sie fest, dass es keine numerische Darstellung zurückgibt, wie wir es uns vorgestellt haben.
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); //true
var 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); //trueIm 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'); //true
var obj2= { };
obj2.valueOf=function(){ return 'b'; }
obj2.toString=function(){ return 'a'; }
console.log(obj2=='a'); //falseIm 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 einem einfachen Wert verglichen werden kann, wird dies der Fall sein direkt verglichen werden, und toString 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 standardmäßig aufgerufen.
PS: js implizite Konvertierungsregeln für Doppel-Gleichheitszeichen
Wenn Sie Doppel-Gleichheitszeichen zum Vergleich verwenden und die beiden Operandentypen unterschiedlich sind, führt das Doppel-Gleichheitszeichen eine implizite Konvertierung durch. Konvertieren, konvertieren in den gleichen Typ und vergleichen Sie dann die Konvertierungsregeln, die Sie auf Seite P51 des Little Red Book finden. (Ich vergesse es immer und habe immer noch das Gefühl, dass gutes Gedächtnis nicht so gut ist wie schlechtes Schreiben. Schreiben hat immer tiefgreifende Auswirkungen)
1. Ein Operand ist ein boolescher Wert und dann vergleichen. Falsch ist 0, wahr ist 1.
2. Eines ist eine Zeichenfolge und das andere ist eine Zahl. Wandeln Sie Zeichenfolgen in Zahlen um und vergleichen Sie sie.
3. Ein Operator ist ein Objekt und der andere ist kein Objekt. Verwenden Sie zuerst valueOf(), um den Objektwerttyp abzurufen, und vergleichen Sie ihn dann gemäß anderen Regeln.
Verwandte Empfehlungen:
Beispiel für einen impliziten Doppelgleichheitszeichen-Konvertierungsmechanismus in Javascript
Implizite Konvertierung von Oracle-Datentypen
Über einige implizite Konvertierungs- und Zusammenfassungsbeispiele in JavaScript
Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des impliziten Konvertierungsmechanismus von doppelten Gleichheitszeichen (==) in Javascript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
