Quel est l'opérateur (== vs ===) qui devrait être utilisé dans les comparaisons JavaScript?

j'utilise JSLint pour passer en JavaScript, et il renvoie de nombreuses suggestions pour remplacer == (deux signes égaux) par === (trois signes égaux) en faisant des choses comme comparer idSele_UNVEHtype.value.length == 0 à l'intérieur d'une déclaration if .

y a-t-il un avantage lié au rendement à remplacer == par === ?

Toute amélioration de la performance serait la bienvenue comme de nombreux opérateurs de comparaison exister.

si aucune conversion de type n'a lieu, y aurait-il un gain de rendement supérieur à == ?

5673
demandé sur Taryn 0000-00-00 00:00:00
la source

30 ответов

l'opérateur d'identité ( === ) se comporte de façon identique à l'opérateur d'égalité ( == ) sauf qu'aucune conversion de type n'est effectuée, et les types doivent être les mêmes pour être considérés égaux.

Référence: Tutorial Javascript: Comparison Operators

l'opérateur == comparera pour égalité après avoir effectué toutes les conversions de type nécessaires . L'opérateur === ne fera pas la conversion, donc si deux valeurs ne sont pas le même type === retournera simplement false . Les deux sont aussi rapides.

pour citer L'excellent de Douglas Crockford JavaScript: The Good Parts ,

JavaScript a deux séries d'opérateurs d'égalité: === et !== , et leurs Jumeaux Maléfiques == et != . Les bons de travail de la façon que vous attendez. Si les deux opérandes sont du même type et ont la même valeur, alors === produit true et !== produit false . Les jumelles maléfiques font la bonne chose quand les opérandes sont du même type, mais si elles sont de différents types, elles tentent de forcer les valeurs. les règles par lesquelles ils ne sont complexes et immémorial. Ces 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

l'absence de transitivité est alarmant. Mon conseil est de ne jamais utiliser les jumelles maléfiques. À la place, Utilisez toujours === et !== . Toutes les comparaisons que nous venons de montrer produisent false avec l'opérateur === .


mise à Jour:

un bon point a été soulevé par @Casebash dans les commentaires et dans @Phillipe Laybaert réponse concernant les types de référence. Pour les types de référence == et === agir de manière cohérente l'un avec l'autre (sauf dans un cas spécial).

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 évalue à la même littérale, en raison de son toString ou valueOf méthode. Par exemple, considérons la comparaison d'une chaîne littérale avec un objet string créé par le constructeur String .

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

ici , l'opérateur == vérifie les valeurs des deux objets et renvoie true , mais le === voit qu'ils ne sont pas du même type et renvoie false . Laquelle est la bonne? Cela dépend vraiment de ce que vous essayez de comparer. Mon conseil est de contourner entièrement la question et de ne pas utiliser le constructeur String pour créer des objets string.

référence

http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

5827
répondu Bill the Lizard 2017-05-23 15:10:45
la source

utilisant l'opérateur == ( Egalité )

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

utilisant l'opérateur === ( identité )

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

c'est parce que le opérateur d'égalité == fait la coercition de type , ce qui signifie que l'interprète tente implicitement de convertir les valeurs avant de comparer.

d'autre part, l'identité l'opérateur === ne fait pas de coercition de type , et ne convertit donc pas les valeurs en comparant.

1012
répondu Kalpesh Rajai 2016-08-20 00:59:57
la source

dans les réponses ici, je n'ai rien lu sur ce que égal signifie. Certains diront que === signifie égal et du même type , mais ce n'est pas vraiment vrai. Cela signifie en fait que les deux opérandes font référence au même objet , ou dans le cas de types de valeurs, ont la même valeur .

donc, prenons 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 n'est pas toujours évident. Il y a plus dans l'histoire qu'être égal et être du même type.

la règle est:

pour les types de valeur (nombres):

a === b renvoie true si a et b ont la même valeur et sont du même type

pour les types de référence:

a === b renvoie true si a et b renvoient exactement au même objet

pour cordes:

a === b renvoie true si a et b sont deux chaînes de caractères et contiennent exactement les mêmes caractères.


Chaînes: le cas particulier...

les chaînes de caractères ne sont pas des types de valeurs, mais en Javascript elles se comportent comme des types de valeurs, de sorte qu'elles seront "égales" lorsque les caractères dans la chaîne de caractères sont les mêmes et lorsqu'elles sont de 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 qu'en est-il de ceci?

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 comportaient comme des types de valeurs? Eh bien, cela dépend de qui vous demandez... Dans ce cas, a et b ne sont pas du même type. a est du type Object , tandis que b est du type string . Il suffit de se rappeler que la création d'un objet string à l'aide du constructeur String crée quelque chose de type Object qui se comporte comme une chaîne de caractères la plupart du temps .

560
répondu Philippe Leybaert 2012-01-10 13:08:34
la source

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

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


var1 === var2

en utilisant === pour le test D'égalité JavaScript, tout est comme tel. Rien se convertit avant d'être évalué.

Equality evaluation of === in JS


var1 == var2

Lorsqu'on utilise == pour les tests D'égalité JavaScript, certains les conversions funky ont lieu.

Equality evaluation of == in JS

Morale de l'histoire:

utilisez === sauf si vous comprenez parfaitement la conversions qui ont lieu avec == .

552
répondu SNag 2018-07-13 20:14:41
la source

Permettez-moi d'ajouter ce conseil:

en cas de doute, lisez la 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 importe plus de savoir comment les navigateurs les plus importants se comportent qu'une définition ésotérique de la façon dont quelque chose est censé être manipulé. Mais il est utile de comprendre pourquoi nouvelle chaîne ("a")!= = "a " .

s'il vous plaît permettez-moi d'expliquer comment lire la spécification pour clarifier cette question. Je vois que dans ce très vieux sujet personne n'a eu de réponse pour l'effet très étrange. Donc, si vous pouvez lire une spécification, cela vous aidera énormément dans votre profession. C'est un acquis de compétences. Donc, nous allons continuer.

la recherche dans le fichier PDF pour === me porte à la page 56 de la spécification: 11.9.4. La Stricte Opérateur égal ( === ) , et après avoir passé en revue la spécification, je trouve:

11.9.6 Algorithme De Comparaison Stricte De L'Égalité

La comparaison x = = y, où x et y sont des valeurs, produit vrai ou faux . Une telle comparaison est effectuée comme suit:

  1. Si le Type (x) diffère du Type(y), retourner false .

  2. Si le Type (x) N'est pas défini, retournez true .

  3. Si le Type (x) est nul, retournez true .

  4. Si le Type(x) n'est pas un nombre, passez à l'étape 11.

  5. Si x est NaN , retournez false .

  6. Si y est NaN , retourner false .

  7. Si x est la même valeur que y, retournez true .

  8. Si x est +0 et y est -0, retourner vrai .

  9. Si x est -0 et y est +0, retourner vrai .

  10. Retourner false .

  11. Si le Type (x) est String, alors retournez vrai si x et y sont exactement la même séquence de caractères (même longueur et mêmes caractères dans les positions correspondantes); sinon, retourner faux .

  12. Si le Type (x) est booléen, retourner vrai si x et y sont tous les deux vrai ou les deux faux ; sinon, retourner faux .

  13. Retour true si x et y font référence au même objet ou s'ils font référence à des objets reliés entre eux (voir 13.1.2). Sinon, retournez false .

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

pas si vite!

vérifions les types d'opérandes. Essayer pour vous-même en les enveloppant dans typeof() . Je trouve que nouvelle chaîne ("a") est un objet, et l'étape 1 est utilisée: retourner false si les types sont différents.

si vous vous demandez pourquoi nouvelle chaîne ("a") ne renvoie pas une chaîne, Que diriez-vous d'un exercice de lecture d'une spécification? Amusez-vous!


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

de la spécification

11.2.2 le nouvel opérateur :

si le type(constructeur) n'est pas un objet, lancer une exception TypeError.

avec d'autres mots, si la chaîne ne serait pas de type Objet, elle ne pourrait pas être utilisée avec le nouvel opérateur.

nouveau retourne toujours un objet, même pour String constructeurs, aussi. Et hélas! La sémantique des valeurs pour les chaînes (voir étape 11) est perdue.

et cela signifie finalement: nouvelle chaîne ("a")!= = "a " .

253
répondu nalply 2015-10-26 13:45:32
la source

en PHP et JavaScript, c'est un opérateur d'égalité strict. Ce qui signifie, il comparera à la fois le type et les valeurs.

94
répondu Shiki 2010-05-12 16:58:39
la source

j'ai testé cela dans Firefox avec Firebug en utilisant le code comme ceci:

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

et

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

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

==: 115.2
===: 114.4

donc je dirais que la minuscule différence (c'est plus de 100000 itérations, rappelez-vous) est négligeable. Performance n'est pas une raison de faire du === . Type de sécurité (bien, aussi sûr que vous allez obtenir en JavaScript), et la qualité du code est.

90
répondu Simon Scarfe 2014-10-26 14:07:41
la source

en JavaScript il signifie de la même valeur et le type.

par exemple,

4 == "4" // will return true

mais

4 === "4" // will return false 
87
répondu Dimitar 2014-10-26 14:11:58
la source

Le === opérateur est appelé un opérateur de comparaison stricte, il ne diffère de la == de l'opérateur.

permet de prendre 2 var a et B.

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

Dans le cas de "= = = b" a et b doit être le même valeur et aussi le même type pour lui d'évaluer à vrai.

prendre 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 l'opérateur = = pourrait évaluer à vrai dans les situations où vous ne voulez pas qu'il ainsi en utilisant l'opérateur = = = serait plus sûr.

dans le scénario d'utilisation de 90%, peu importe lequel vous utilisez, mais il est pratique de savoir la différence quand vous obtenez un comportement inattendu un jour.

76
répondu Doctor Jones 2013-08-21 12:39:53
la source

il vérifie si les 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 courant:

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

autre exemple courant:

null == undefined // returns "true", but in most cases a distinction is necessary
68
répondu vsync 2018-07-19 10:04:17
la source

pourquoi == est-il si imprévisible?

que recevez-vous quand vous comparez une chaîne vide "" avec le nombre zéro 0 ?

true

Yep, c'est exact selon == une chaîne vide et le nombre zéro sont la même heure.

Et il ne s'arrête pas là, en voici une autre:

'0' == false // true

les choses deviennent vraiment bizarres avec les tableaux.

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

puis weirder à cordes

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

C'est pire:

Quand est égal à é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 le répéter:

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

et c'est juste le truc fou qu'on a avec les primitifs.

C'est un tout nouveau niveau de folie quand on utilise == avec des objets.

à ce stade, vous vous demandez probablement...

pourquoi cela se produit-il?

Eh bien c'est parce que contrairement à "triple égale" ( === ) qui vérifie juste si deux valeurs sont les mêmes.

== est-ce un tas d'autres trucs .

il a la manipulation spéciale pour les fonctions, la manipulation spéciale pour nulls, Non défini, chaînes, vous l'appelez.

c'est assez dingue.

en fait, si vous essayiez d'écrire une fonction qui fait ce que == fait, cela 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?

ça veut dire == est compliqué.

Parce que c'est compliqué, il est difficile de savoir ce qui va se passer quand vous l'utilisez.

ce qui signifie que vous pourriez finir avec des insectes.

Donc la morale de l'histoire est...

rend ta vie moins compliquée.

utiliser === au lieu de == .

À La Fin.

66
répondu Luis Perez 2018-04-21 18:39:44
la source

exécution de Javascript diagramme de flux pour une égalité stricte Comparaison '==='

Javascript strict equality

exécution de Javascript diagramme de flux pour les non stricte égalité et de comparaison '=='

Javascript non equality

63
répondu Samar Panda 2015-09-05 16:53:16
la source

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
52
répondu Anik Islam Abhi 2015-11-12 06:18:12
la source

signifie égalité sans contrainte de type type coercition signifie que JavaScript ne convertit pas automatiquement d'autres types de données en type de données

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 
51
répondu Pop Catalin 2017-07-31 00:40:44
la source

dans un scénario typique, il n'y aura pas de différence de performances. Plus important peut être le fait que thousand "= = = "est 1 KB plus lourd que thousand"==":) profileurs JavaScript peut vous dire s'il y a une différence de performance dans votre cas.

mais personnellement je ferais ce que JSLint suggère. Cette recommandation n'existe pas en raison de problèmes de rendement, mais parce que la coercition de type signifie ('\t\r\n' == 0) est vraie.

46
répondu Constantin 2017-05-23 15:02:56
la source

L'égalité de l'opérateur de comparaison ==, est prête à confusion et devrait être évitée.

si vous devez vivre avec, alors rappelez-vous les 3 choses suivantes:

  1. Il n'est pas transitive: (a == b) et (b == c) ne conduit pas à (a == c)
  2. c'est mutuellement exclusif à sa négation: (a == b) et (a != b) toujours tenir les valeurs booléennes opposées, avec tous les a et B.
  3. en cas de doute, apprenez par cœur la table de vérité suivante:

TABLE DE VÉRITÉ DE L'OPÉRATEUR D'ÉGALITÉ EN JAVASCRIPT

  • chaque ligne dans le tableau est un ensemble de 3 mutuellement valeurs "égales", c'est-à-dire que 2 valeurs parmi elles sont égales en utilisant le signe = = = *

* * étrange: notez que deux valeurs sur la première colonne ne sont pas égales dans 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.
42
répondu CuongHuyTo 2014-02-19 19:01:17
la source

il est peu probable qu'il y ait une différence de performance entre les deux opérations dans votre utilisation. Il n'y a pas de conversion de type à faire car les deux paramètres sont déjà du même type. Les deux opérations auront une comparaison de type suivie d'une comparaison de valeur.

35
répondu Sean 2008-12-11 17:44:55
la source

Oui! c'est important.

=== " l'opérateur en javascript vérifie la valeur ainsi que le type où comme == l'opérateur vérifie juste la valeur (fait la conversion de type si nécessaire) .

enter image description here

vous pouvez facilement le 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 obtenez ' false " en alerte. Maintenant, Modifiez la méthode onPageLoad() en alert(x == 5); vous obtiendrez vrai .

35
répondu Aniket Thakur 2015-01-10 17:34:14
la source

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

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

32
répondu Niraj CHoubey 2017-11-20 15:05:13
la source

c'est un contrôle strict.

c'est une bonne chose surtout si vous cochez entre 0 et false et null.

par exemple, si vous avez:

$a = 0;

puis:

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

tout retourne vrai et vous pouvez ne pas vouloir cela. Supposons que vous ayez une fonction qui peut retourner le 0ème index d'un tableau ou false en cas d'échec. Si vous cochez "==" false, Vous pouvez obtenir un résultat confus.

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
30
répondu Daniel 2015-04-27 11:26:10
la source

JSLint vous donne parfois des raisons irréalistes de modifier des trucs. === a exactement la même performance que == si les types sont déjà les mêmes.

il est plus rapide que lorsque les types ne sont pas les mêmes, auquel cas il n'essaie pas de convertir les types mais retourne directement un false.

So, IMHO, JSLint peut-être utilisé pour écrire un nouveau code, mais inutile sur-Optimisation devrait être évitée à tout prix.

signifie, Il n'y a aucune raison de changer == en === dans un chèque comme if (a == 'test') quand vous le savez pour un fait qu'une ne peut être qu'une chaîne.

Modifier beaucoup de code de façon à gaspiller le temps des développeurs et des réviseurs et à ne rien obtenir.

29
répondu ashes 2017-11-20 15:11:45
la source

simplement

== signifie comparaison entre les opérandes avec type conversion

&

=== signifie comparaison entre les opérandes sans type conversion

La conversion de Type

en javaScript signifie que javaScript convertit automatiquement tous les autres types de données en types de données de 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 
28
répondu Amit 2017-11-20 15:49:58
la source

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.
25
répondu Vikas 2015-07-04 06:56:47
la source

les deux premières réponses mentionnées == signifie égalité et === signifie identité. Malheureusement, cette affirmation est inexacte.

si les deux opérandes de == sont des objets, alors elles sont comparées pour voir si elles sont le même objet. Si les deux opérandes pointent vers le même objet, alors l'opérateur equal renvoie true. 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, = = et === get faux car a et b ne sont pas les mêmes objet.

C'est-à-dire: si les deux opérandes de == sont des objets, == se comporte de la même façon que ===, ce qui signifie aussi identité. La différence essentielle de ces deux opérateurs concerne la conversion de type. = = a la conversion avant de vérifier l'égalité, mais = = = n'a pas.

23
répondu Harry He 2013-09-09 12:31:45
la source

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

raisons sont expliquées dans les réponses ci-dessus et aussi Douglas Crockford est assez clair à ce sujet ( JavaScript: les bonnes parties ).

Cependant il est une exception : == null est un moyen efficace de vérifier si 'est nul ou non défini':

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

par exemple jQuery 1.9.1 utilise ce motif 43 fois, et le JSHint syntax checker fournit même l'option eqnull relaxing pour cette raison.

De la jQuery guide de style :

des contrôles stricts de l'égalité ( = = = ) devraient être utilisés en faveur de ==. La seule exception est lors de la vérification des indéfini et nulle par null.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;
22
répondu mar10 2013-04-27 18:15:38
la source

De la base de référence javascript

=== Renvoie true si les opérandes sont strictement égales (voir ci-dessus) avec aucune conversion de type.

22
répondu Paul Butcher 2015-11-12 06:17:34
la source

le problème est que vous pourriez facilement avoir des problèmes depuis JavaScript ont beaucoup de conversions implicites sens...

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

qui devient vite un problème. Le meilleur exemple de pourquoi la conversion implicite est "evil" peut être pris à partir de ce code dans MFC / C++ qui va en fait compiler en raison d'une conversion implicite de CString à HANDLE qui est un type de pointeur typedef...

CString x;
delete x;

qui évidemment, pendant l'exécution ne très choses non définies...

Google pour les conversions implicites en C++ et STL pour obtenir certains des arguments contre elle...

21
répondu Thomas Hansen 2014-10-26 14:08:37
la source

comparaison d'Égalité:

Opérateur ==

retourne true, lorsque les deux opérandes sont égales. Les opérandes sont convertis au même type avant d'être comparées.

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

l'Égalité et le type de comparaison:

Opérateur ===

renvoie true si les deux opérandes sont égales et du même type. C'est généralement mieux et plus sûr si vous comparez de cette façon, parce qu'il n'y a pas de conversions de type dans les coulisses.

>>> 1 === '1'
false
>>> 1 === 1
true
20
répondu user2601995 2013-10-03 01:54:43
la source

* opérateurs = = = vs == *

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true
18
répondu Mr.G 2014-03-19 16:08:11
la source

null et undefined sont le néant, qui est,

var a;
var b = null;

Ici a et b n'ont pas de valeurs. Alors que, 0, false et " sont toutes des valeurs. Une chose commune entre tous ceux-ci sont qu'ils sont tous des valeurs falsy, ce qui signifie qu'ils tous satisfont conditions falsy.

ainsi, le 0, le faux et le " ensemble forment un sous-groupe. Et d'autre part, null & undefined forme le second sous-groupe. De vérifier la les comparaisons dans l'image ci-dessous. nul et non défini serait égal. Les trois autres seraient égaux les uns aux autres. Mais, ils sont tous traités comme des conditions falsy dans JavaScript.

Enter image description here

c'est le même que n'importe quel objet (comme {}, tableaux, etc.), non-empty string & Boolean true sont toutes des conditions truthy. Mais, ils sont tous égaux.

18
répondu 2014-10-26 14:15:19
la source