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

Question

Récemment, j'ai été l'exécution de certains de mon code par le biais de JSLint quand je suis venu avec cette erreur. La chose que je pense est drôle à propos de cette erreur, même si c'est qu'il suppose automatiquement que tous =====.

N'a vraiment aucun sens? J'ai pu voir un grand nombre de cas que vous ne voulez pas de comparer le type, et je suis inquiet que cela pourrait en fait causer des problèmes.

Le mot "Devrait" impliquerait que cela devrait être fait à CHAQUE fois.....Qu'est ce qui ne fait pas de sens pour moi.

Métropole

Answer 1

OMI, aveuglément à l'aide de ===, sans essayer de comprendre comment la conversion de type de travaux n'a pas beaucoup de sens.

La principale crainte au sujet de l'opérateur = == , c'est que les règles de comparaison en fonction des types de rapport peut faire l'opérateur non-transitive, par exemple, si:

A == B AND
B == C

N'a pas vraiment de garantit que:

A == C

Par exemple:

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

La Stricte opérateur = === n'est pas vraiment nécessaire lorsque vous comparez des valeurs de même type, l'exemple le plus courant:

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

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

Ou lorsque vous connaissez les règles de contrainte de type, par exemple, de vérifier 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
}

Answer 2

JSLint est intrinsèquement plus défensive que la syntaxe Javascript permet.

À partir de la JSLint de la documentation:

L' == et != opérateurs de faire de ce type de contrainte avant de les comparer. Ce est mauvais parce qu'il provoque ' \t\r\n' == 0 pour être vrai. Cela peut masquer des erreurs de type.

Si l'on compare à l'une des valeurs suivantes, utilisez l' === ou !== opérateurs (qui ne font pas de contrainte de type): 0 '' undefined null false true

Si vous ne garde qu'une valeur est truthy ou falsy, puis utiliser la forme courte. Au lieu de

(foo != 0)

juste dire

(foo)

et au lieu de

(foo == 0)

dire

(!foo)

L' === et !== des opérateurs sont privilégiées.

Answer 3

Gardez à l'esprit que JSLint impose à une personne l'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 modifications suggérées.

En général, comparer le type et 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 devoir).

Answer 4

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

Donc, ("4" == 4) est vrai, alors qu' ("4" === 4) est faux.

Triple égalité gère également légèrement plus rapide, parce que JavaScript n'est pas perdre du temps à faire toutes les conversions de type avant de vous donner la réponse.

JSLint est délibérément visant à faire de votre code JavaScript aussi stricte que possible, avec l'objectif de réduire de bogues obscures. Il met en évidence ce genre de chose pour essayer de vous obtenir le code de la manière qui vous oblige à l'égard des types de données.

Mais la bonne chose à propos de JSLint est que c'est juste un guide. Comme ils le disent sur le site, il ne sera blesser 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 vous le comprenez, mais vous êtes sûr que votre code ne va pas casser, alors il n'y a pas de contrainte sur vous pour changer quoi que ce soit.

Vous pouvez même dire JSLint à ignorer les catégories de contrôles si vous ne voulez pas être bombardés avec des avertissements que vous n'allez pas faire quoi que ce soit.

Answer 5

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 contrainte. En particulier, n'utilisez pas == pour comparer avec les valeurs de fausseté.

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