Explication détaillée de la définition et de l'utilisation des expressions relationnelles dans le cours de base JavaScript

Les opérateurs relationnels sont utilisés pour tester une relation entre deux valeurs (égalité, inférieur à ou "est une propriété de"), renvoyant vrai et faux selon que la relation existe ou non. Les expressions relationnelles renvoient toujours une valeur booléenne, les expressions relationnelles sont généralement utilisées dans les instructions if while ou for pour contrôler le flux d'exécution du programme.

iOpérateurs d'égalité et d'inégalité

Les opérateurs "==" et "===" sont utilisés pour comparer si deux valeurs sont égales. Les deux opérateurs autorisent tout type d'opérateur. Renvoie vrai s'ils sont égaux, sinon renvoie faux. "===" est également appelé opérateur d'égalité stricte (parfois appelé opérateur d'identité), qui est utilisé pour détecter si deux opérandes sont strictement égaux. L'opérateur "==" est appelé opérateur d'égalité, qui est utilisé pour vérifier si deux opérandes sont égaux. La définition de l'égalité ici est vague et permet la conversion de type.

Javascript prend en charge les opérateurs "=", "==", "===", vous devez comprendre la différence entre les opérateurs (affectation, égalité, identité). Et utilisez-le avec précaution dans la programmation. Pour réduire la confusion, "=" doit être appelé "obtenir ou attribuer", "==" doit être appelé "égalité" et "===" doit être appelé "égalité stricte".

Les règles des opérateurs "!=" et "!==" sont "==", la négation de l'opérateur "===", "!" est un opérateur booléen NOT, nous allons "!= ", "!==" s'appelle inégalité, pas égalité stricte

La comparaison d'objets JavaScript est une comparaison de références, pas une comparaison de valeurs. L'objet est égal à lui-même, mais ni la personne ni l'objet ne sont égaux. Si deux objets ont le même nombre de propriétés, les mêmes noms et valeurs de propriété, ils ne sont toujours pas égaux. Même si les éléments du tableau aux positions correspondantes sont égaux, les deux tableaux sont également inégaux.

L'opérateur d'égalité stricte "===" calcule d'abord la valeur de l'opérande, puis compare les deux valeurs sans aucune conversion de type.

Si deux valeurs ne sont pas du même type, elles ne sont pas égales
Si les deux valeurs sont nulles ou indéfinies, elles ne sont pas égales
Si les deux valeurs sont booléennes vraies ou faux, alors ils sont égaux
Si l'une des valeurs est NaN, ou si les deux valeurs sont NaN, alors elles ne sont pas égales NaN et les autres valeurs ne sont pas égales, y compris elle-même.
Deux valeurs sont égales si ce sont des nombres et égales. Si une valeur est 0 et une valeur est -0, elles sont également égales.
Si deux valeurs sont des chaînes et que les 16 chiffres (voir chapitre 3, section 2) contenus dans les bits correspondants sont exactement égaux, ils sont égaux. S’ils sont différents en longueur ou en contenu, ils ne sont pas égaux. Deux chaînes peuvent fonctionner exactement de la même manière et afficher les mêmes caractères, mais avoir des valeurs de 16 bits sans codage. JavaScript n'effectue pas de conversion standard en Unicode, ces chaînes sont donc transmises via "===" et "==". les résultats de comparaison des opérateurs ne sont pas non plus égaux. String.localeCompare() dans la partie 3 fournit une autre façon de comparer des chaînes.
Deux valeurs de référence sont égales si elles pointent vers le même objet, tableau ou fonction. S’ils pointent vers des objets différents, ils ne sont pas égaux, même si les deux objets ont exactement les mêmes propriétés.
L'opérateur d'égalité "==" est similaire à l'opérateur d'identité, mais la comparaison des opérateurs d'égalité n'est pas stricte. Si les deux nombres ne sont pas du même type, l'opérateur d'égalité tente une conversion de type puis les compare.

Si les deux types d'opérations sont identiques, les règles de comparaison sont les mêmes que celles de l'opérateur d'égalité ci-dessus. S'ils sont strictement égaux, les résultats de la comparaison sont égaux. S’ils ne sont pas strictement égaux, la comparaison aboutit à une inégalité.
Si deux types d'opérations sont différents, l'opérateur d'égalité "==" les considérera également égaux. La détection de l'égalité suivra les règles et conversions de types suivantes :
Si un type est nul et l'autre n'est pas défini, ils sont égaux
Si une valeur est un nombre et l'autre est une chaîne, convertissez d'abord la chaîne en un number , puis utilisez la valeur convertie à des fins de comparaison.
Si une valeur est vraie, convertissez-la en 1 pour comparaison. Si une valeur est fausse, convertissez-la en 0 pour comparaison.
Si une valeur est un objet et l'autre valeur est un nombre ou une chaîne, utilisez les règles de conversion de la méthode du chapitre 3, section 8, sous-section 3 pour convertir l'objet en une valeur primitive, puis comparez. L'objet est converti en valeur primitive via la méthode toString() ou la méthode valueOf(). Les classes intégrées au cœur du langage JavaScript essaient d'abord d'utiliser valueOf(), puis d'utiliser toString(). À l'exception de la classe date, la classe date ne peut être convertie que via toString(). Les objets qui ne font pas partie du langage JavaScript principal sont convertis en valeurs primitives à l'aide de méthodes définies dans l'implémentation.
Les comparaisons entre d'autres types différents ne sont pas égales
Voici un petit exemple d'égalité

"1" == true
Le résultat de cette expression est vrai, ce qui indique qu'elle est complètement Les valeurs de différents types sont comparées pour être égales. Le booléen vrai est d'abord converti en nombre 1 avant que la comparaison ne soit effectuée. Ensuite, la chaîne "1" sera également convertie en nombre 1, car les valeurs des deux nombres sont égales, donc le résultat est vrai.

ii L'opérateur de comparaison

est inférieur à (c3d0cf9c388841d4f63ec36aedbd52a9)

Supérieur ou égal à (>=)

....(ne détaillant pas la signification)

Les opérandes des opérateurs de comparaison peuvent être de n'importe quel type. Cependant, seuls les nombres et les chaînes peuvent réellement effectuer des opérateurs de comparaison, donc tous les opérandes qui ne sont pas des nombres ou des chaînes subiront une conversion de type. Les règles de conversion de type sont les suivantes :

Si l'opérande est un objet, il est converti en valeur primitive selon les règles de conversion décrites dans la description du verrou au chapitre 3, section 8, sous-section 3 : If valueOf () renvoie une valeur primitive, puis utilise directement cette valeur primitive. Sinon, le résultat de la conversion de toString() est utilisé à des fins de comparaison.
Après avoir converti la paire en valeur primitive, si les deux opérandes sont des chaînes, alors les deux chaînes seront comparées par ordre alphabétique. L'ordre alphabétique mentionné ici est la composition des deux. L'ordre d'index des 16 bits. Caractères Unicode de la chaîne.
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 comparés numériquement. 0 et -0 sont égaux. Infinty est plus grand que tout autre nombre (sauf l'infini lui-même) et -infinty est plus petit que n'importe quel nombre (sauf lui-même.) Si un opérande (ou converti) est NaN, l'opérateur de comparaison renvoie toujours false
pour les valeurs numériques et les chaînes. opérateurs, l'opérateur plus se comporte différemment de l'opérateur de comparaison. Le premier préfère les chaînes et effectue la concaténation des chaînes si l'un de ses opérandes est une chaîne. Les opérateurs de comparaison préfèrent les nombres uniquement lorsque les deux opérandes sont des chaînes. Une comparaison de chaînes sera effectuée.

1 + 2 //=>3 addition, le résultat est 3
"1" + "2" //Concaténation de chaînes, le résultat est "12"
"1" + 2 / /Concaténation de chaînes, 2 est converti en "2", le résultat est "12"
11 dff4128426f331982f430e3de568e608=" ne s'appuient pas sur l'opérateur d'égalité et sur des règles strictes de comparaison d'égalité pour déterminer l'égalité . En revanche, l'opérateur inférieur ou égal est simplement « pas supérieur à » et l'opérateur supérieur ou égal est simplement « pas inférieur à ». Il n'y a qu'une seule exception, lorsque l'un des opérandes (après conversion) est NaN, les 4 opérateurs de comparaison renverront fasle.

opérateur iii.in

opérateur in Espérons que son opérande gauche soit un chaîne ou peut être converti en chaîne, et son côté droit est censé être un objet. L'expression renvoie vrai si l'objet de droite a un nom de propriété nommé valeur de l'opérande de gauche. Par exemple,

var point = {
     x: 1,
     y: 1
   } //定义一个对象
   "x" in point //=>true 对象有一个名为x的属性
   "z" in point //=>false 对象无名为z的属性
   "toString" in point // =>true 对象继承了toString方法
   var data = [7, 8, 8]
            "0" in data //=>true 数组包含0
             1 in data //=>true 数字转换为字符串
             3 in data //=>fase 没有索引为3的元素

opérateur iiii.instanceof

opérateur instanceof s'attend à ce que l'opérateur de gauche soit un. objet, et l’opérande de droite indique la classe de l’objet. Si l'objet de gauche est une instance de la classe de droite, l'expression renvoie true ; elle est chargée de renvoyer false. Le chapitre 9 en parlera. Les classes d'objets JavaScript sont définies en initialisant leurs constructeurs. Dans ce cas, l'opérande droit de instanceof doit être une fonction. Par exemple :

var d = new Date(); //构造一个新对象
  d instanceof Date; //计算结果为true， d是Date() 创建的
  d instanceof Object //计算结果为true ,所有的对象都是Object的实例
  d instanceof Number //计算结果为 false，d不是一个Number对象
  var a = [1,2,3] //数组直接量创建数组
  a instanceof Array //计算结果true a为数组
  a instanceof Object //true 所有的数组都是对象
  a instanceof RegExp //fasle 数组不是正则表达式

Il convient de noter que tous les objets sont des instances de Object. Lors de la vérification si un objet est une instance d'une classe via instanceof, ce jugement est également appelé détection de "superclasse". Si l'objet d'opération gauche d'instanceof n'est pas un objet, instanceof renvoie false. Si l’opération de droite n’est pas une fonction, une exception de typewrong est levée.

Afin de comprendre le fonctionnement de l'opérateur instanceof, vous devez d'abord comprendre la « chaîne de prototypes ». La chaîne de prototypes, en tant que mécanisme d'héritage de JavaScript, sera décrite en détail dans le chapitre 6, section 2, section. 2.

Afin de calculer l'expression o instanceof f, JavaScript BiXian calcule d'abord f.prototyoe, puis interroge o dans la chaîne de prototypes. S'il est trouvé, alors o est une instance de f (ou la classe parent de f. ), puis renvoie vrai. Sinon faux

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!