Quelle est la raison d'utiliser === au lieu de == avec typeof en Javascript?

Pour répondre à la question principale – il n'y a pas danger d'utiliser typeof avec == . Voici la raison pour laquelle vous pouvez utiliser === toute façon.

La recommandation de Crockford est qu'il est plus sûr d'utiliser === dans de nombreuses circonstances, et que si vous l'utilisez dans certaines circonstances, il est préférable d'être cohérent et de l'utiliser pour tout.

La pensée est que vous pouvez penser à utiliser == ou === chaque fois que vous vérifiez l'égalité, ou vous pouvez simplement avoir l'habitude d'écrire toujours === .

Il n'y a pratiquement jamais de raison d'utiliser == over === – si vous comparez à true ou false et vous voulez une coercition (par exemple, vous voulez que 0 ou '' évalué à false ), utilisez simplement if(! empty_str) plutôt que if(empty_str == false) .

Pour ceux qui ne comprennent pas les problèmes de == dehors du contexte de typeof, voir cela, à partir de The Good Parts :

 '' == '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 

Si l'opérateur typeof renvoie déjà une chaîne, quel type de type vérifier la valeur de retour? Si typeof (typeof (x)) est toujours une chaîne, peu importe ce que x est effectivement, alors == devrait être suffisant et === inutile.

C'est subjectif. Vous pouvez tout simplement tourner cela et demander: "Pourquoi utiliseriez-vous == lorsque vous ne vous attendez pas à des conversions implicites?" Les deux fonctionnent bien ici, alors utilisez celui que vous ressentez pour mieux dire votre intention. Essayez d'être cohérent dans un projet.

Il n'y a aucune raison de favoriser === sur == dans ce cas, puisque les deux opérandes sont garantis comme des chaînes et les deux opérateurs donneront donc le même résultat. Puisque == est un personnage moins, je préférerais cela.

Le conseil de Crockford à ce sujet est d'utiliser === tout le temps, ce qui est un conseil raisonnable pour un débutant mais inutilement paranoïaque si vous connaissez les problèmes (abordés dans d'autres réponses).

Parce que === est plus rapide que ==, en raison de l'omission de la contrainte de type. Bien sûr, c'est probablement une différence négligeable, mais c'est toujours là.

Les opérateurs triplement égaux sont principalement utilisés pour le contrôle de type et de valeur de variable (tous en 1 expression), également appelé contrainte d'égalité sans type .

Exemple:

 var a = 1; var b = 1; var c = "1"; var d = "1"; alert (a === b); //True, same value and same type (numeric) alert(c === d); //True, same value and same type (string) alert(b === c); //False, different type but same value of 1 

Voir le théâtre YUI de Doug Crockford sur la coercition de type.

Si l'opérateur typeof renvoie déjà une chaîne, quel type de type vérifier la valeur de retour? Si typeof (typeof (x)) est toujours une chaîne, peu importe ce que x est effectivement, alors == devrait être suffisant et === inutile.

La raison la plus efficace pour ne pas utiliser typeof et plutôt l'opérateur === serait la contrainte de type (interprétation) entre les navigateurs. Certains navigateurs peuvent passer 6=="6" comme étant vrais et certains ne le seraient pas (en fonction de la rigueur de l'interprète JS), alors en introduisant la coercition de type, le clarifierait. En outre, cela entraînerait une approche «orientée vers l'objet» car les variables de JavasScript ne sont pas des variables de type (par exemple, les types de variables ne sont pas déclarés au moment de la compilation comme Java).

Par exemple, en Java, cela échouerait:

 if ("6" instanceof Number) { // false 

J'espère que j'ai répondu à votre question.