Vergleichsoperatoren in Javascript-Operatoren analysieren

Inhalt

[1] Identität [2] Gleich [3] Größer als [4] Kleiner als

Vorherige Wörter

Beziehung Operator wird verwendet, um die Beziehung zwischen zwei Werten zu testen Beziehung Gibt wahr oder falsch zurück, unabhängig davon, ob sie existiert. Der Beziehungs--Ausdruck gibt immer einen booleschen Wert zurück, normalerweise in if, while oder for-Anweisung Relationale Ausdrücke werden verwendet, um den Ausführungsfluss des Programms zu steuern.

　Javascript bietet ===, !==, ==, !=, <, <=, > ;, > = 8 relationale Operatoren, dieser Artikel wird in 4 Kategorien unterteilt, um die relationalen Operatoren

Identitätsoperator

Identitätsoperator '== =', auch genannt, vorzustellen Der strikte Gleichheitsoperator berechnet zuerst den Wert seines Operanden und vergleicht dann die beiden Werte. Der Vergleichsprozess hat keine Typkonvertierung. Der Vergleichsprozess ist wie folgt:

　1 】Wenn die beiden Werte unterschiedlichen Typs sind, geben Sie false zurück

console.log(1 === '1');//false
console.log(1 === [1]);//false

　【2】Wenn beide Werte undefiniert sind, Null, Boolean, Number, StringWenn für Werte desselben primitiven Typs die Werte gleich sind, geben Sie true zurück, andernfalls geben Sie false zurück

console.log(undefined === undefined);//true
console.log(null === null);//true

console.log(true === true);//true
console.log(false === false);//true

console.log(1 === 1);//true
console.log(2.5 === 2.5);//true

　[Hinweis] Unabhängig von der Basis der Zahl wird sie bei der Durchführung eines relationalen Vergleichs schließlich zur Berechnung in eine Dezimalzahl umgewandelt

console.log(10 === 0xa);//true

Im Zahlentyp Unter ihnen gibt es einen Sonderwert, nämlich NaN (keine Zahl), der keinem Wert entspricht. Darüber hinaus gibt es +0 und -0 der Zahlentyp. Obwohl ihre Vorzeichen unterschiedlich sind, sind die Werte gleich

console.log(NaN === NaN);//false
console.log(+0 === -0);//true

Zwei identische Zeichenfolgen Werte verhalten sich wie folgt: gleiche Länge und die gleichen Zeichen entsprechen der gleichen Position

console.log('abc' === 'abc');//true
console.log('abc' === 'acb');//false

　【3】Wenn sich zwei Werte auf dasselbe Objekt , dann true zurückgeben, andernfalls false zurückgeben
　[Hinweis] Ausführlichere Erklärung Ja, der Vergleich von
Javascript-Objekt ist ein Referenzvergleich, kein Wertvergleich. Das Objekt ist gleich zu sich selbst, aber nicht gleich zu irgendeinem anderen Objekt, wenn zwei verschiedene Objekte die gleiche Anzahl Attribute, den gleichen Attributnamen und -wert haben, sind sie immer noch nicht gleich

console.log([] === []);//false
console.log({} === {});//false    
console.log(function(){} === function(){});//false

var a = {};
b = a;
console.log(a === b);//true

[Identitätsungleichheitsoperator]

Der Identitätsoperator (!==) wird auch als strikter Ungleichheitsoperator bezeichnet Der Operand ist derselbe wie der Identitätsoperator und das Ergebnis wird negiert. Wenn das Vergleichsergebnis von „===“ wahr ist, ist das Vergleichsergebnis von „!==“ falsch. Wenn das Vergleichsergebnis von „===“ falsch ist, ist das Vergleichsergebnis von „!==“ falsch wahr

console.log(1 !== '1');//true
console.log(1 !== 1);//false
console.log(true !== false);//true
console.log({} !== {});//true

Gleichheitsoperator

Der Gleichheitsoperator „==“ ähnelt dem Identitätsoperator, der Vergleich des Gleichheitsoperators ist jedoch nicht streng Da die beiden Operanden nicht vom gleichen Typ sind, versucht der Gleichheitsoperator, vor dem Vergleich einige Typkonvertierungen durchzuführen

Wenn die beiden Operandentypen gleich sind, sind die Vergleichsregeln dieselben wie die Regeln des Identitätsoperators

console.log(undefined == undefined);//true
console.log(10 == 0xa);//true
console.log(NaN == NaN);//false
console.log([] == []);//false

Wenn die beiden Operandentypen unterschiedlich sind, entspricht der Gleichheitsoperator „==“ den folgenden Regeln:

【1】Wenn ein Wert ist Ein Objekttyp, der andere Wert ist ein primitiver Typ. Der Objekttyp wird zuerst mit valueOf() in einen primitiven Wert konvertiert. Wenn das Ergebnis kein primitiver Wert ist, wird es dann mit der Methode toString() konvertiert verglichen

[Hinweis] Die Datumsklasse erlaubt nur die Konvertierung in einen String mit der toString()-Methode. Wenn Sie ein Time
Date-Objekt hinzufügen, verwenden Sie toString(), um es in eine Zeichenfolge umzuwandeln, während bei anderen mathematischen Operationen, einschließlich Subtraktion, Multiplikation, Division, Rest usw., Number() zur Konvertierung verwendet wird Funktion konvertiert das Zeit-Datumsobjekt mit valueOf() in eine Zahl
[2] Nachdem das Objekt in den ursprünglichen Wert konvertiert wurde und beide Operanden Zeichenfolgen sind, fahren Sie mit dem Zeichenfolgenvergleich fort

console.log(new Date() == 'Sat Jun 25 2016 11:07:20 GMT+0800 (中国标准时间)');//true

[3] Nachdem das Objekt in einen primitiven Wert konvertiert wurde und mindestens ein Operand keine Zeichenfolge ist, werden beide Operanden an Number () übergeben. Die Transformationsfunktion wandelt Zahlen in Zahlen für den numerischen Vergleich um

console.log(true == 1);//true
console.log(true == 0);//false
console.log(false == '1');//false
console.log(false == '0');//true
console.log(true == 'true');//false，相当于1 == NaN

console.log([1] == 1);//true，相当于1 == 1
console.log([1] == '1');//true，相当于'1' == '1'
console.log([] == 0);//true，相当于0 == 0
console.log([] == '0');//false，相当于'' == '0'

console.log([] == true);//false，相当于0 == 1
console.log([1] == true);//true，相当于1 == 1

var a = {
    valueOf:function(){
        return 1;
    },
    toString:function(){
        return '2';
    }
} 
console.log( a == '1');//true，相当于1 == 1

var a = {
    valueOf:function(){
        return {};
    },
    toString:function(){
        return '1';
    }
} 
console.log( a == 1);//true，相当于1 == 1

[Hinweis] Wenn ein Wert null ist, gilt der andere Wenn ein Wert undefiniert ist, geben Sie true zurück. Obwohl Number (null) 0 ist, sind null und 0 nicht gleich

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

　[Hinweis] Leere Zeichenfolgen oder Leerzeichenfolgen werden in 0 konvertiert

console.log(null == []);//false
console.log(null == '');//false
console.log([] == ' ');//false，相当于'' == ' '
console.log([] == '');//true，相当于'' == ''
console.log(0 == '');//true

【不相等运算符】

　　不相等运算符(!=)的操作数比较过程与相等运算符相同，结果取反。如果'=='的比较结果是true，则'!='的比较结果是false；如果'=='的比较结果是false，则'!='的比较结果是true

console.log(1 != '1');//false，相当于1 != 1
console.log(true != '1');//false，相当于1 != 1
console.log('true' != 1);//true，相当于NaN != 1
console.log([1] != '1');//false，相当于'1' != '1'
console.log([1] != true);//false，相当于1 != 1

大于运算符

　　大于运算符(>)用于比较两个操作数，如果第一个操作数大于第二个操作数，则大于运算符的计算结果为true，否则为false

　　大于运算符的操作数可能是任意类型，然而，只有数字和字符串才能真正执行比较操作，因此那些不是数字和字符串的操作数都将进行类型转换，类型转换规则如下：

　　【1】如果操作数是对象，则这个对象将先使用valueOf()转换成原始值，如果结果还不是原始值，则再使用toString()方法转换

　　[注意]实际上，在原生对象中，使用valueOf()方法转换为原始值的，只有转换为数字Number类型的时间Date对象，其他对象都通过toString()方法成了字符串

　　【2】在对象转换为原始值之后，如果两个操作数都是字符串，则按照字母表的顺序对两个字符串进行比较，这里提到的字母表顺序是指组成这个字符串的16位unicode字符的索引顺序

console.log('b' > 'a');//true
console.log('B' > 'a');//false

console.log({} > '[a]');//true，相当于'[object Object]' > '[a]'
console.log({} > '[p]');//false，相当于'[object Object]' > '[p]'

console.log([a] > [b]);//false，相当于'[a]' > '[b]'
console.log([2] > [11]);//true，相当于'[2]' > '[11]'

　　[注意]虽然在字母表中大写字母在小写字母的前面，所以大写字母 < 小写字母；但字符串String对象有一个字符串比较的方法localeCompare()方法会考虑自然语言的排序情况，把'B'排在'a'的后面，该方法在字符串在字母表中排在其参数之前时，返回一个负数；字符串在字母表中排在其参数之后时，返回一个正数

console.log('B'.localeCompare('a'));//1
console.log('B' > 'a');//false
console.log('b'.localeCompare('a'));//1
console.log('b' > 'a');//true</p>
<p><br>　　【3】在对象转换为原始值之后，如果至少有一个操作数不是字符串，则两个操作数都转换成数字进行比较<br><br>　　[注意]在等于<a href="http://www.php.cn/wiki/996.html" target="_blank">操作符</a>中，时间Date()对象只允许通过toString()方法转换为字符串，而不允许通过valueOf()方法转换为数字；而在大于操作符中，时间Date()对象允许优先使用valueOf()方法转换为数字 <br><br></p>
<pre class="brush:php;toolbar:false">console.log(new Date() > 100);//true，相当于1466826928667 > 100
console.log(true > [0]);//true，相当于 1 > 0

console.log(2 > 1);//true
console.log(11 > '2');//true，相当于11 > 2

console.log(NaN > 1);//false
console.log(1 > NaN);//false
console.log({} > true);//false，相当于 NaN > 1

　　[注意]虽然null == 0的结果为false，这是因为javascript将null == undefined的结果设为true。在大于运算中，null和undefined进行Number()转型函数转换分别转换为0和NaN

console.log(undefined > -1);//false，相当于NaN > -1
console.log(null > -1);//true，相当于0 > -1
console.log(undefined > 0);//false，相当于NaN > 0
console.log(null > 0);//false，相当于0 > 0

　　对于数字和字符串来说，加号运算符和比较运算符的行为有所不同，加号运算符更偏爱字符串，如果它的一个操作数是字符串，就进行字符串连接。而比较运算符则更偏爱数字，只有在两个操作数都是字符串时，才进行字符串的比较

console.log(1 + 2);//3
console.log('1' + '2');//'12'
console.log('1' + 2);//'12'，相当于 '1' + '2'

console.log(2 > 1);//true
console.log('2' > '1');//true
console.log('2' > 1);//true，相当于 2 > 1

【小于等于运算符】

　　小于等于运算符(<=)并不依赖于小于或等于运算符的比较规则，而是遵循大于运算符的比较规则，结果取反。如果'>'的比较结果是true，则'<='的比较结果是false；如果'>'的比较结果是false，则'<='的比较结果是true

console.log(1 <= &#39;0&#39;);//false，相当于1 <= 0
console.log(true <= &#39;0&#39;);//false，相当于1 <= 0
console.log(&#39;true&#39; <= 0);//false，相当于NaN <= 0
console.log([1] <= &#39;0&#39;);//false，相当于&#39;1&#39; <= &#39;0&#39;
console.log([0] <= true);//true，相当于0 <= 1
console.log(1 <= 1);//true

小于运算符

　　小于运算符(<)用于比较两个操作数，如果第一个操作数小于第二个操作数，则小于运算符的计算结果为true，否则为false

　　小于运算符与大于运算符的类型转换规则类似，就不再赘述

【大于等于运算符】

　　同样地，大于等于运算符(>=)并不依赖于大于或等于运算符的比较规则，而是遵循小于运算符的比较规则，结果取反。如果'<'的比较结果是true，则'>='的结果是false；如果'<'的比较结果是false，则'>='的结果是true

Das obige ist der detaillierte Inhalt vonVergleichsoperatoren in Javascript-Operatoren analysieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!