Analyse des opérateurs relationnels dans les opérateurs javascript

Contenu

[1] Identité [2] Égal [3] Supérieur à [4] Inférieur à

Mots précédents

Relation L'opérateur permet de tester la relation entre deux valeurs, selon le relation Renvoie vrai ou faux, qu'elle existe. La relation expression renvoie toujours une valeur booléenne, généralement dans if, while ou for . Les expressions relationnelles sont utilisées pour contrôler le flux d'exécution du programme

　javascript fournit ===, !==, ==, !=, <, <=, > ;, > = 8 opérateurs relationnels, cet article sera divisé en 4 catégories pour présenter les opérateurs relationnels

Opérateur d'identité

Opérateur d'identité '== =', également appelé l'opérateur d'égalité stricte, calcule d'abord la valeur de son opérande, puis compare les deux valeurs. Le processus de comparaison n'a pas de conversion de type Le processus de comparaison est le suivant :

　[. 1 】Si les deux valeurs sont de types différents, retournez false

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

　【2】Si les deux valeurs sont Indéfinies, Null, Boolean, Number, StringPour les valeurs du même type primitif, si les valeurs sont les mêmes, retournez vrai, sinon, retournez faux

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

　[Remarque] Quelle que soit la base du nombre, lors de la comparaison relationnelle, il sera éventuellement converti en décimal pour le calcul

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

Dans le type Nombre Parmi eux, il y a une valeur spéciale, qui est NaN (pas un nombre), qui n'est égale à aucune valeur, de plus, il y a +0 et -0 dans ; le type Nombre. Bien que leurs signes soient différents, les valeurs sont égales

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

Deux chaînes valeurs identiques se comportent comme suit : la même longueur. et les mêmes caractères correspondant à la même position

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

　【3】Si deux valeurs font référence à le même objet , puis retournez vrai, sinon retournez faux

　[Note] Explication plus détaillée Oui, la comparaison de objet javascript est une comparaison de référence, pas une comparaison de valeur L'objet est égal. à lui-même, mais n'est égal à aucun autre objet si deux objets différents ont le même numéro Attributs, le même nom d'attribut et la même valeur, ils ne sont toujours pas égaux

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

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

[Opérateur d'inégalité d'identité]

L'opérateur d'identité (!==) est également appelé l'opérateur d'inégalité stricte Le processus de comparaison de. les opérandes sont les mêmes que l'opérateur d'identité et le résultat est annulé. Si le résultat de la comparaison de '===' est vrai, alors le résultat de la comparaison de '!==' est faux ; si le résultat de la comparaison de '===' est faux, alors le résultat de la comparaison de '!==' est faux ; true

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

Opérateur d'égalité

L'opérateur d'égalité '==' est similaire à l'opérateur d'identité, mais la comparaison de l'opérateur d'égalité n'est pas stricte If. les deux opérandes ne sont pas du même type, l'opérateur d'égalité tentera d'effectuer quelques conversions de types avant comparaison

Lorsque les deux types d'opérandes sont identiques, les règles de comparaison sont les mêmes que les règles de l'opérateur d'identité

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

Lorsque les deux types d'opérandes sont différents, l'opérateur d'égalité '==' respectera les règles suivantes :

【1】Si une valeur est un type d'objet, l'autre valeur est un type primitif, le type d'objet sera d'abord converti en valeur primitive à l'aide de valueOf(). Si le résultat n'est pas une valeur primitive, il sera alors converti à l'aide de la méthode toString() puis. par rapport

[Note] La classe Date autorise uniquement la conversion en chaîne à l'aide de la méthode toString(). De même, lors de l'ajout d'un objet Time
Date, utilisez toString() pour le convertir en chaîne, tandis que dans d'autres opérations mathématiques, notamment la soustraction, la multiplication, la division, le reste, etc., Number() est utilisé. Conversion la fonction convertit l'objet heure Date en nombre à l'aide de valueOf()
[2] Une fois l'objet converti en valeur d'origine, si les deux opérandes sont des chaînes, passez à la comparaison de chaînes de

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

[3] Une fois l'objet converti en valeur primitive, si au moins un opérande n'est pas une chaîne, les deux opérandes seront transmis à Number () La fonction de transformation convertit les nombres en nombres pour une comparaison numérique

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

[Remarque] Si une valeur est nulle, l'autre Si une valeur n'est pas définie, renvoie vrai. Bien que le nombre (null) soit 0, null et 0 ne sont pas égaux

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

　[Remarque] Les chaînes vides ou les chaînes d'espace seront converties en 0

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!