Ce qui équivaut à l'opérateur (== === vs) doit être utilisé dans les comparaisons JavaScript?

https://stackoverflow.com/questions/359494

21-08-2019
|

Question

J'utilise JSLint pour passer par JavaScript, et il est de retour de nombreuses suggestions pour remplacer < => (deux signes égal) avec trois (== signes égal) lorsque vous faites des choses comme comparer à l'intérieur d'une === idSele_UNVEHtype.value.length == 0 déclaration.

Y at-il un avantage de performance pour le remplacement avec if <=>?

Toute amélioration de la performance serait accueillie comme de nombreux opérateurs de comparaison existent.

Si aucune conversion de type a lieu, y aurait-il un gain de performance sur <=>?

La solution

L'opérateur identité (===) se comporte de manière identique à l'opérateur d'égalité (==) à l'exception aucune conversion de type est fait, et les types doivent être les mêmes à considérer égaux.

Référence: Javascript Tutoriel: Opérateurs de comparaison

L'opérateur comparera pour false l'égalité après avoir fait des conversions de types nécessaires . L'opérateur sera !== pas faire la conversion, donc si deux valeurs ne sont pas le même type renverra simplement != true. Les deux sont tout aussi rapide.

Pour citer une excellente JavaScript: The Good Parts ,

JavaScript a deux ensembles d'opérateurs d'égalité: et toString valueOf, et leurs mauvais jumeaux et String <=>. Les bons fonctionnent comme on peut s'y attendre. Si les deux opérandes sont du même type et ont la même valeur, et <=> produit <=> produit <=> <=>. Les jumeaux maléfiques font la bonne chose lorsque les opérandes sont du même type, mais si elles sont de différents types, ils tentent de contraindre les valeurs. les règles selon lesquelles ils font cela sont complexes et immémorial. Ce sont quelques-uns des cas intéressants:
'' == '0'           // false
0 == ''             // true
0 == '0'            // true

false == 'false'    // false
false == '0'        // true

false == undefined  // false
false == null       // false
null == undefined   // true

' \t\r\n ' == 0     // true
Le manque de transitivité est alarmante. Mon conseil est de ne jamais utiliser les jumeaux maléfiques. Au lieu de cela, utilisez toujours et <=> <=>. Toutes les comparaisons viennent de montrer des produits avec l'opérateur <=> de <=>.

Mise à jour:

Un bon point a été élevé par @Casebash dans les commentaires et dans @Phillipe Laybaert href="https://stackoverflow.com/a/957602/1288"> répondre concernant les types de référence. Pour les types de référence et <=> agir de manière cohérente avec <=> un autre (sauf dans un cas particulier).

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Le cas particulier est lorsque vous comparez un littéral avec un objet qui permet d'évaluer au même littéral, en raison de sa méthode ou <=> <=>. Par exemple, considérons la comparaison d'une chaîne littérale avec un objet chaîne créée par le constructeur <=>.

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Ici, l'opérateur vérifie les <=> valeurs des deux objets et retour <=>, mais le voit que <=> ils ne sont pas le même type et le retour <=>. Laquelle est correcte? Cela dépend vraiment de ce que vous essayez de comparer. Mon conseil est de contourner entièrement la question et il suffit de ne pas utiliser le constructeur pour créer des objets <=> string.

Référence http://www.ecma-international.org/ecma- 262 / 5.1 / # sec-11.9.3

Autres conseils

Utilisation de l'opérateur de == ( L'égalité )

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Utilisation de l'opérateur de === ( Identité )

true === 1; //false
"2" === 2;  //false

En effet, le opérateur d'égalité ne coercition de type <=> , ce qui signifie que l'interprète tente implicitement de convertir les valeurs avant de comparer.

D'autre part, le opérateur d'identité <=> ne fait contrainte de type pas , et donc ne convertit pas les valeurs lorsque l'on compare, et est donc plus rapide (comme selon Cette référence JS test ) comme il saute un pas.

Une représentation picturale intéressante de la comparaison de l'égalité entre les et == ===.

Source: http://dorey.github.io/JavaScript-Equality- Tableau /

`var1 === var2`

Lors de l'utilisation pour les tests de var1 == var2 égalité JavaScript, tout est comme il est. Rien ne se converti avant d'être évalué.

évaluation de l'égalité === en JS

<=>

Lors de l'utilisation pour les tests de <=> égalité JavaScript, certains conversions géniales ont lieu.

évaluation de l'égalité == en JS

Morale de l'histoire:

Utiliser si vous ne comprenez <=> pleinement la   les conversions qui ont lieu avec <=>.

Dans les réponses ici, je ne l'ai pas lu quelque chose sur ce que égale signifie. Certains diront que ===> égaux et du même type , mais ce n'est pas vraiment vrai. Cela signifie en fait que les deux opérandes référence le même objet , ou en cas de les types de valeur, ont la même valeur .

Alors, nous allons prendre le code suivant:

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

La même chose ici:

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Ou même:

var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Ce comportement est pas toujours évident. Il y a plus à l'histoire que d'être égaux et être du même type.

La règle est:

Pour les types de valeurs (chiffres): Renvoie true si a === b et a ont la même b valeur et sont du même type

Pour les types de référence: Renvoie true si Object et string String font référence au même objet exact

Pour les chaînes: Retourne vrai si <=> et <=> sont les deux chaînes <=> et contiennent les mêmes caractères exacts

Cordes: le cas particulier ...

Les chaînes ne sont pas les types de valeur, mais en Javascript ils se comportent comme des types de valeur, de sorte qu'ils seront « égaux » lorsque les caractères de la chaîne sont les mêmes et quand ils sont de la même longueur (comme expliqué dans la troisième règle)

Maintenant, il devient intéressant:

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

Mais que diriez-vous?

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

Je pensais que les chaînes se comportent comme des types de valeur? Eh bien, cela dépend de qui vous demandez ... Dans ce cas, et b ne sont pas du même type. Est de type <=> <=>, tandis que est de type <=> <=>. Rappelez-vous que la création d'un objet de chaîne à l'aide du constructeur crée quelque chose de <=> le type qui se comporte comme <=> une chaîne la plupart du temps .

Permettez-moi d'ajouter ce conseil:

En cas de doute, consultez le spécification

ECMA-262 est la spécification d'un langage de script dont JavaScript est un dialecte. Bien sûr, dans la pratique, il est plus important comment les navigateurs les plus importants se comportent d'une définition ésotérique de la façon dont quelque chose est censé être manipulé. Mais il est utile de comprendre pourquoi new String ( "a")! == "a" .

S'il vous plaît laissez-moi vous expliquer comment lire la spécification de clarifier cette question. Je vois que dans ce nobody sujet très ancien avait une réponse pour l'effet très étrange. Donc, si vous pouvez lire une spécification, cela vous aidera dans votre profession énormément. Il est une compétence acquise. Alors, nous allons continuer.

Recherche dans le fichier PDF pour === me amène à la page 56 du cahier des charges: 11.9.4. La stricte Equals opérateur (===) , et après patauger dans l'specificationalese je trouve:

11.9.6 L'égalité Comparaison Algorithme Strict   La comparaison x === y, où x et y sont des valeurs, produit true ou false . Une telle comparaison est réalisée comme suit:
  1. Si le type (x) est différent de type (y), retour false .
  2. Si le type (x) est non défini, retour true .
  3. Si le type (x) est nul, le retour true .
  4. Si le type (x) n'est pas Nombre, passez à l'étape 11.
  5. Si x est NaN , retour false .
  6. Si y est NaN , retour false .
  7. Si x est la même valeur numérique que y, retour true .
  8. Si x est 0 et y est -0, retour true .
  9. Si x est -0 et y est 0, retour true .
  10. Retour false .
  11. Si le type (x) est une chaîne, puis revenez true si x et y sont exactement la même séquence de caractères (même longueur et mêmes caractères dans des positions correspondant); sinon, retour false .
  12. Si le type (x) est booléenne, retour true si x et y sont à la fois true , ou les deux false ; sinon, retour false .
  13. Retour true si x et y font référence au même objet ou si elles se rapportent à des objets reliés les uns aux autres (voir 13.1.2). Dans le cas contraire, le retour false .

Il est intéressant étape 11. Oui, les chaînes sont traitées comme des types de valeur. Mais cela n'explique pas pourquoi new String ( "a")! == "a" . Avons-nous un navigateur non conforme à la norme ECMA-262?

Pas si vite!

Voyons les types des opérandes. Essayez-le par vous-même en les enveloppant dans typeof () . Je trouve que new String ( "a") est un objet, et l'étape 1 est utilisé. Retour false si les types sont différents

Si vous vous demandez pourquoi new String ( "a") ne renvoie pas une chaîne, que diriez-vous un peu d'exercice la lecture d'un cahier des charges? Amusez-vous bien!

Aidiakapi a écrit ceci dans un commentaire ci-dessous:

De la spécification

11.2.2 Le nouvel opérateur :

Si le type (constructeur) est l'objet, de jeter une exception TypeError.

Avec d'autres termes, si la chaîne ne serait pas de type objet, il ne pouvait pas être utilisé avec le nouvel opérateur.

nouveau renvoie toujours un objet, même pour string constructeurs, aussi. Et hélas! La sémantique de valeur pour les chaînes (voir l'étape 11) est perdue.

Et cela signifie enfin:. new String ( "a") == "a"

En PHP et JavaScript, il est un opérateur d'égalité stricte. Ce qui signifie, il compare les deux types et les valeurs.

Je l'ai testé ce dans Firefox avec href="http://en.wikipedia.org/wiki/Firebug_%28software%29" Firebug en utilisant le code comme ceci:

console.time("testEquality");
var n = 0;
while(true) {
    n++;
    if(n==100000) 
        break;
}
console.timeEnd("testEquality");

console.time("testTypeEquality");
var n = 0;
while(true) {
    n++;
    if(n===100000) 
        break;
}
console.timeEnd("testTypeEquality");

Mes résultats (testé cinq fois chacun et en moyenne):

==: 115.2
===: 114.4

Je dirais que la différence minuscule (ce qui est plus 100000 itérations, rappelez-vous) est négligeable. Performance ne sont pas une raison de faire ===. Tapez la sécurité (bien, aussi sûr que vous allez obtenir en JavaScript), et la qualité du code est.

En JavaScript cela signifie la même valeur et le type.

Par exemple,

4 == "4" // will return true

4 === "4" // will return false

=== opérateur est appelé un opérateur de comparaison stricte, il fait différent du == opérateur.

permet de prendre deux vars a et b.

"a == b" pour évaluer à vrai besoin a et b être la même valeur .

Dans le cas de "a === b" a et b doit être la même valeur et aussi le même type pour elle d'évaluer la valeur true.

Prenons l'exemple suivant

var a = 1;
var b = "1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

En résumé ; en utilisant le == opérateur peut évaluer à vrai dans les situations où vous ne voulez pas à l'aide si la === opérateur serait plus sûr.

Dans le scénario d'utilisation de 90%, il ne sera pas question que celui que vous utilisez, mais il est utile de connaître la différence quand vous obtenez un comportement inattendu un jour.

Il vérifie si mêmes côtés sont égaux en type ainsi que valeur .

Exemple:

'1' === 1 // will return "false" because `string` is not a `number`

Exemple commun:

0 == ''  // will be "true", but it's very common to want this check to be "false"

Un autre exemple courant:

null == undefined // returns "true", but in most cases a distinction is necessary

Pourquoi est si imprévisible ==?

Qu'est-ce que vous obtenez lorsque vous comparez une chaîne vide avec le numéro "" zéro 0?

true

Yep, tout à fait selon === une chaîne vide et le nombre zéro sont en même temps.

Et il ne se termine pas là, voici un autre:

'0' == false // true

Les choses deviennent vraiment bizarre avec des tableaux.

[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true

Puis plus étrange avec des cordes

[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!

de se aggraver:

Quand est égal non égal?

let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string

A == B // true - ok... 
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

Permettez-moi de dire encore une fois que:

(A == B) && (B == C) // true
(A == C) // **FALSE**

Et ceci est juste le truc fou que vous obtenez des primitives.

Il est un tout nouveau niveau de fou lorsque vous utilisez des objets <=>.

À ce stade, vous vous demandez probablement ...

Pourquoi cela?

Eh bien, c'est parce que contrairement à « égaux » triple (<=>) qui vérifie simplement si deux valeurs sont les mêmes.

<=> fait un tas d'autres choses .

Il a un traitement spécial pour les fonctions, un traitement spécial pour les valeurs nulles, non défini, les chaînes, vous le nom.

get assez loufoque.

En fait, si vous avez essayé d'écrire une fonction qui fait ce que serait-t-il <=> ressemblerait à quelque chose comme ceci:

function isEqual(x, y) { // if `==` were a function
    if(typeof y === typeof x) return y === x;
    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof y === "function" || typeof x === "function") {
        // if either value is a string 
        // convert the function into a string and compare
        if(typeof x === "string") {
            return x === y.toString();
        } else if(typeof y === "string") {
            return x.toString() === y;
        } 
        return false;
    }

    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);
    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the "+" trick
    if(typeof x !== "number") x = +x;
    if(typeof y !== "number") y = +y;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

Alors qu'est-ce que cela signifie?

Cela signifie est compliqué <=>.

Parce qu'il est compliqué, il est difficile de savoir ce qui va se passer lorsque vous l'utilisez.

Ce qui signifie que vous pourriez finir avec les bugs.

La morale de l'histoire est ...

Faites votre vie moins compliquée.

Utilisez au lieu de <=> <=>.

La fin.

organigramme d'exécution Javascript pour l'égalité stricte / Comparaison '==='

organigramme d'exécution Javascript pour l'égalité / comparaison stricte non '=='

JavaScript === vs ==.

0==false   // true
0===false  // false, because they are of a different type
1=="1"     // true, auto type coercion
1==="1"    // false, because they are of a different type

Cela signifie L'égalité sans contrainte de type signifie coercition de type JavaScript ne convertit pas automatiquement les autres types de données à des types de données chaîne

0==false   // true,although they are different types

0===false  // false,as they are different types

2=='2'    //true,different types,one is string and another is integer but 
            javaScript convert 2 to string by using == operator 

2==='2'  //false because by using === operator ,javaScript do not convert 
           integer to string 

2===2   //true because both have same value and same types

Dans un script typique il n'y aura pas de différence de performance. Plus important encore peut-être le fait que mille « === » est 1 Ko plus lourd que mille « == » :) JavaScript profileurs peut vous dire s'il y a une différence de performance dans votre cas.

Mais personnellement, je ferais ce que suggère JSLint. Cette recommandation est-il pas en raison de problèmes de performance, mais parce que la contrainte de type signifie est vrai ('\t\r\n' == 0).

L'opérateur de comparaison égale == est source de confusion et doit être évité.

Si vous DOIVENT en direct avec elle, alors souvenez-vous les 3 choses suivantes:

Il est pas transitive: (a == b) et (b == c) ne conduit pas à (a == c )
Il est mutuellement exclusif à sa négation: (a == b) et (! A = b) toujours tenir en face des valeurs booléennes, avec tout un et b.
En cas de doute, apprendre par cœur la table de vérité suivante:

TABLE EGAL VÉRITÉ JAVASCRIPT

Chaque ligne de la table est un ensemble de 3 valeurs mutuellement égales « », ce qui signifie que les 2 valeurs sont égales entre elles à l'aide du même signe == *

** STRANGE:. Noter que les deux valeurs de la première colonne ne sont pas égaux en ce sens **

''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
'0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
'\t'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\t\r\n' == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

null == undefined  // These two "default" values are not-equal to any of the listed values above
NaN                // NaN is not equal to any thing, even to itself.

Il est peu probable que toute différence de performance entre les deux opérations dans votre utilisation. Il n'y a aucun type de conversion à faire parce que les deux paramètres sont déjà le même type. Les deux opérations auront une comparaison de type suivie d'une comparaison de la valeur.

Oui! Il importe.

=== opérateur javascript valeur vérifie ainsi que le type où que l'opérateur contrôle simplement == la valeur (ne conversion de type si nécessaire) .

entrer image description ici

Vous pouvez facilement tester. Coller le code suivant dans un fichier HTML et l'ouvrir dans le navigateur

<script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>

Vous obtiendrez ' false en alerte. maintenant modifier la méthode pour vous onPageLoad() obtiendrez alert(x == 5); true .

=== opérateur vérifie les valeurs ainsi que les types des variables pour l'égalité.

opérateur == juste vérifie la valeur des variables pour l'égalité.

Il est un test de contrôle strict.

Il est une bonne chose, surtout si vous vérifiez entre 0 et faux et nul.

Par exemple, si vous avez:

$a = 0;

Alors:

$a==0; 
$a==NULL;
$a==false;

Tous les retours vrais et vous ne voudrez peut-être cela. Supposons que vous avez une fonction qui peut renvoyer l'indice 0e d'un tableau ou faux en cas d'échec. Si vous vérifiez avec « == » false, vous pouvez obtenir un résultat déroutant.

Donc, avec la même chose que ci-dessus, mais un test strict:

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false

JSLint vous donne parfois des raisons irréalistes pour modifier des choses. A exactement la === mêmes performances que si les types == sont déjà les mêmes.

Il est plus rapide que lorsque les types ne sont pas identiques, auquel cas il ne cherche pas à convertir les types mais retourne directement un faux.

à mon humble avis, JSLint peut-être utilisé pour écrire un nouveau code, mais inutile sur-optimisation doit être évitée à tout prix.

Signification, il n'y a aucune raison de changer à if (a == 'test') un chèque <=> comme quand vous savez <=> pour un fait que ne peut être une chaîne.

Modification beaucoup de code que les développeurs de façon déchets et des examinateurs de temps et ne sert à rien.

Il suffit

== moyen comparaison entre opérandes avec type conversion

=== moyen comparaison entre opérandes sans <=>

Conversion de type en javaScript signifie javaScript convertir automatiquement les autres types de données à des types de données chaîne.

Par exemple:

123=='123'   //will return true, because JS convert integer 123 to string '123'
             //as we used '==' operator 

123==='123' //will return false, because JS do not convert integer 123 to string 
            //'123' as we used '===' operator

Un exemple simple est

2 == '2'  -> true, values are SAME because of type conversion.

2 === '2'  -> false, values are NOT SAME because of no type conversion.

En règle générale, j'utiliser en général au lieu de === == (et au lieu de !== !=).

Les raisons sont expliquées dans les réponses ci-dessus et Douglas Crockford est assez clair à ce sujet ( JavaScript:. The Good Parts )

Cependant, il y a une seule exception : Est un moyen == null efficace pour vérifier « est nulle ou non définie »:

if( value == null ){
    // value is either null or undefined
}

Par exemple jQuery 1.9.1 utilise ce modèle 43 fois, et JSHint vérificateur de syntaxe fournit même l'option de détente pour cette eqnull raison.

De la guide de style jQuery :

vérifie l'égalité stricte (===) devraient être utilisés en faveur de ==. Le seul exception est définie lors de la vérification de null et à titre d'null.
// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

Les 2 réponses les deux == mentionné signifie l'égalité et === signifie l'identité. Malheureusement, cette affirmation est incorrecte.

Si les deux opérandes de == sont des objets, ils sont comparés pour voir si elles sont le même objet. Si les deux opérandes pointent vers le même objet, l'opérateur égal retourne vrai. Autrement, les deux ne sont pas égaux.

var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  // false  
console.log(a === b) // false

Dans le code ci-dessus, à la fois == et === obtenir de faux parce que a et b ne sont pas les mêmes objets.

C'est-à-dire: si les deux opérandes de == sont des objets, == se comporte même comme ===, ce qui signifie aussi l'identité. La différence essentielle de ces deux opérateurs est sur la conversion de type. == a conversion avant qu'il vérifie l'égalité, mais === ne fonctionne pas.

Le problème est que vous pourriez facilement avoir des ennuis depuis JavaScript ont beaucoup de conversions implicites qui signifie ...

var x = 0;
var isTrue = x == null;
var isFalse = x === null;

Quel joli devient bientôt un problème. Le meilleur échantillon de la raison pour laquelle la conversion implicite est « mal » peut être pris à partir de ce code dans MFC / C ++ qui en fait la compilation en raison d'une conversion implicite de CString à poignée qui est un pointeur de type typedef ...

CString x;
delete x;

Ce qui évidemment lors de l'exécution fait très choses non définies ...

Google pour les conversions implicites en C ++ et STL pour obtenir quelques-uns des arguments contre .. .

De la référence

=== Retourne si les opérandes true sont strictement égaux (voir ci-dessus) sans conversion de type.

comparaison de l'égalité:

Opérateur ==

Retourne true, lorsque les deux opérandes sont égaux. Les opérandes sont convertis au même type avant d'être comparés.

>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true

l'égalité et la comparaison du type:

Opérateur ===

Renvoie true si les deux opérandes sont égaux et du même type. Il est généralement meilleur et plus sûr si l'on compare cette façon, parce qu'il n'y a pas de conversions de type derrière les coulisses.

>>> 1 === '1'
false
>>> 1 === 1
true

* Les opérateurs == === vs *

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true

Voici un tableau comparatif pratique qui montre les conversions qui se produisent et les différences entre et == ===.

Comme la conclusion indique:

"Utilisez trois égaux à moins que vous comprenez les conversions qui prennent place pour deux égaux ».

http://dorey.github.io/JavaScript-Equality-Table/

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow