JSLint attendu '===' et a plutôt vu '=='

Récemment, j'exécutais une partie de mon code via JSLint lorsque j'ai rencontré cette erreur. La chose que je trouve amusante à propos de cette erreur, c'est qu'elle suppose automatiquement que tout == doit être ===.

Cela a-t-il vraiment un sens? Je pourrais voir un grand nombre de cas où vous ne voudriez pas comparer le type, et je crains que cela puisse causer des problèmes.

Le mot «prévu» impliquerait que cela devrait être fait CHAQUE fois ..... C'est ce qui n'a pas de sens pour moi.

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

La principale crainte à propos de l'opérateur Equals ==est que les règles de comparaison en fonction des 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' typeofopérateur, qui est toujours une chaîne , avec une chaîne littérale ...

Ou lorsque vous connaissez les règles de coercition de type, par exemple, vérifiez si quelque chose est nullou 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
}

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

À partir de la documentation JSLint:

Les opérateurs ==et !=saisissent la coercition avant de comparer. C'est mauvais parce que c'est ' \t\r\n' == 0vrai. Cela peut masquer les erreurs de type.

Lorsque vous comparez à l'une des valeurs suivantes, utilisez les opérateurs ===ou !==(qui ne font pas de coercition de type):0 '' undefined null false true

Si vous vous souciez seulement qu'une valeur soit vraie ou fausse , utilisez la forme courte. Au lieu de

(foo != 0)

dis le

(foo)

et au lieu de

(foo == 0)

dire

(!foo)

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

Gardez à l'esprit que JSLint applique une idée de ce que devrait être un bon JavaScript. Vous devez toujours faire preuve de bon sens lors de la mise en œuvre des changements qu'il suggère.

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

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.

C'est ("4" == 4)vrai, alors que ("4" === 4)c'est faux.

Triple-égal 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 bogues obscurs. Il met en évidence ce genre de chose pour essayer de vous amener à 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 vous blessera, 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 se cassera pas, alors vous n'êtes pas obligé de changer quoi que ce soit.

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

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 leur propre validation.

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

if (foo == null)

mais permet

if (!foo)

Pour aider à expliquer cette question et également expliquer pourquoi NetBeans (à partir de) 7.3 a commencé à afficher cet avertissement, ceci est 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 les 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 à la place les opérateurs === et! == les plus fiables.

Référence

Eh bien, cela 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 cela ne le présente pas comme un problème.