web-dev-qa-db-fra.com

JSLint attendait '===' et a vu à la place '=='

Récemment, j'exécutais une partie de mon code via JSLint lorsque j'ai trouvé cette erreur. La chose que je pense est drôle à propos de cette erreur, c'est qu'elle suppose automatiquement que tous les == doivent être ===.

Est-ce vraiment logique? Je pourrais voir beaucoup d'exemples que vous ne voudriez pas comparer le type, et je crains que cela puisse réellement causer des problèmes.

Le mot "attendu" impliquerait que cela devrait être fait CHAQUE fois ..... C'est ce qui n'a pas de sens pour moi.

javascriptjslint
81
Metropolis

OMI, utilisant aveuglément ===, sans essayer de comprendre comment la conversion de type fonctionne n'a pas beaucoup de sens.

La principale peur de l'opérateur Equals == est que les règles de comparaison selon les types comparés peuvent rendre l'opérateur non transitif, par exemple si:

A == B AND
B == C

Ne garantit pas vraiment que:

A == C

Par exemple:

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

L'opérateur Strict Equals === n'est pas vraiment nécessaire lorsque vous comparez des valeurs du même type, l'exemple le plus courant:

if (typeof foo == "function") {
  //..
}

Nous comparons le résultat de l'opérateur typeof, qui est toujours une chaîne , avec un chaîne littérale ...

Ou lorsque vous connaissez les règles de coercition de type, par exemple, vérifiez si quelque chose est null ou undefinedquelque chose:

if (foo == null) {
  // foo is null or undefined
}

// Vs. the following non-sense version:

if (foo === null || typeof foo === "undefined") {
  // foo is null or undefined
}
122
CMS

JSLint est intrinsèquement plus défensif que ne le permet la syntaxe Javascript.

De la documentation JSLint:

Le == et != les opérateurs saisissent la coercition avant de comparer. C'est mauvais car cela provoque ' \t\r\n' == 0 pour être vrai. Cela peut masquer des erreurs de type.

Lors de la comparaison avec l'une des valeurs suivantes, utilisez le === ou !== opérateurs (qui ne font pas de type coercition): 0 '' undefined null false true

Si vous vous souciez seulement qu'une valeur soit véridique ou falsy, alors utilisez le formulaire court. Au lieu de

(foo != 0)

dis le

(foo)

et au lieu de

(foo == 0)

dire

(!foo)

Le === et !== les opérateurs sont préférés.

25
Daniel Vandersluis

Gardez à l'esprit que JSLint impose à une personne l'idée de ce que doit être un bon JavaScript. Vous devez toujours faire preuve de bon sens lors de la mise en œuvre des modifications suggérées.

En général, la comparaison du type et de la valeur rendra votre code plus sûr (vous ne rencontrerez pas le comportement inattendu lorsque la conversion de type ne fait pas ce que vous pensez qu'il devrait).

17
Justin Niessner

Triple-égal est différent de double-égal car en plus de vérifier si les deux côtés ont la même valeur, triple-égal vérifie également qu'ils sont du même type de données.

Alors ("4" == 4) est vrai, tandis que ("4" === 4) c'est faux.

La triple égalité s'exécute également un peu plus rapidement, car JavaScript n'a pas à perdre de temps à effectuer des conversions de type avant de vous donner la réponse.

JSLint vise délibérément à rendre votre code JavaScript aussi strict que possible, dans le but de réduire les bugs obscurs. Il met en évidence ce genre de chose pour essayer de vous faire coder d'une manière qui vous oblige à respecter les types de données.

Mais la bonne chose à propos de JSLint est que ce n'est qu'un guide. Comme on dit sur le site, cela nuira à vos sentiments, même si vous êtes un très bon programmeur JavaScript. Mais vous ne devriez pas vous sentir obligé de suivre ses conseils. Si vous avez lu ce qu'il a à dire et que vous le comprenez, mais que vous êtes sûr que votre code ne va pas se casser, alors vous n'êtes pas obligé de changer quoi que ce soit.

Vous pouvez même dire à JSLint d'ignorer les catégories de contrôles si vous ne voulez pas être bombardé d'avertissements sur lesquels vous n'allez rien faire.

12
Spudley

Une citation de http://javascript.crockford.com/code.html :

=== et! == Opérateurs.

Il est presque toujours préférable d'utiliser les opérateurs === et! ==. Les opérateurs == et! = Saisissent la coercition. En particulier, n'utilisez pas == pour comparer avec des valeurs fausses.

JSLint est très strict, leur 'webjslint.js' ne passe même pas sa propre validation.

8
Lekensteyn

Pour aider à expliquer cette question et également expliquer pourquoi NetBeans (from) 7.3 a commencé à afficher cet avertissement, il s'agit d'un extrait de la réponse sur le suivi des bogues NetBeans lorsque quelqu'un a signalé cela comme un bogue:

Il est recommandé d'utiliser === plutôt que == en JavaScript.

Les opérateurs == et! = Saisissent la coercition avant de comparer. Ceci est mauvais car cela rend vrai '\ t\r\n' == 0. Cela peut masquer des erreurs de type. JSLint ne peut pas déterminer de manière fiable si == est utilisé correctement, il est donc préférable de ne pas utiliser du tout == et! = Et de toujours utiliser les opérateurs === et! == les plus fiables à la place.

Référence

3
EM-Creations

Si vous voulez tester la fausseté. JSLint ne permet pas

if (foo == null)

mais permet

if (!foo)
3
nano2nd

Eh bien, ça ne peut pas vraiment causer de problèmes, c'est juste vous donner des conseils. À prendre ou a laisser. Cela dit, je ne sais pas à quel point c'est intelligent. Il peut bien y avoir des contextes dans lesquels il ne le présente pas comme un problème.

2
Rushyo