Je ne peux pas savoir si -1 est vrai ou faux en javascript, quand j'utilise indexOf. Pourquoi les deux dernières lignes donnent-elles vrai/faux?En JavaScript est -1 vrai ou faux?
D'après ce que je comprends que == permet pour le type de conversion, car (=== est stricte)
est-(! A) et (! B) en utilisant (==) en interne quelque part?
De MDN:
En JavaScript, une valeur truthy est une valeur qui se traduit par true lorsqu'elle est évaluée dans un contexte booléen. Toutes les valeurs sont vraies sauf si elles sont définies comme étant falsifiées (c'est-à-dire, à l'exception de false, 0, "", null, indéfini et NaN). (Souligné par l'auteur)
Cela signifie -1 est considéré comme "truthy". Vous ne devriez pas vérifier la "véracité" directement sur la valeur retournée de indexOf de toute façon. -1 a un spécifique ce qui signifie que l'élément que vous recherchez n'existe pas dans le tableau. Il serait donc plus logique de tester explicitement contre -1 en utilisant ===. Pour quiconque lit le code, l'intention est aussi beaucoup plus claire que de forcer la valeur de retour de indexOf et de prendre votre décision en fonction de cela.
À part la lisibilité, y a-t-il autre chose de mal à utiliser (!) Directement avec indexOf? Un cas où la valeur n'est pas trouvée retournera toujours -1 (vérité), ce qui rend le résultat final faux. Alors pourquoi utiliser la syntaxe plus longue de .indexOf ('string')> -1 – roro
La syntaxe plus longue parle de ce que vous faites réellement (c'est-à-dire de rechercher l'index d'un élément dans un tableau). Les index valides vont de 0 à length - 1. C'est donc plus intuitif que de forcer la valeur d'un booléen. Contraindre et tester n'est pas très utile de toute façon, car autre que «0», tous les autres index sont «véridiques», alors que la seule valeur qui vous intéresse vraiment est «-1», qui est également vraie. Donc, vous devrez faire quelque chose comme 'arr.indexOf (i) && arr.indexOf (i)> -1' pour voir si vous avez un index valide. Alors pourquoi ne pas faire 'arr.indexOf (i)> -1' de toute façon? –
Juste une modification mineure au commentaire ci-dessus. L'expression complète serait '(arr.indexOf (i) && arr.indexOf (i)! == -1) || ! arr.indexOf (i) ', ce qui est plus compliqué que de simplement vérifier' arr.indexOf (i)! == -1'. –
Pour vérifier ce qui est la conversion de certaines variables en booléen, le meilleur truc est d'utiliser un opérateur booléen. Par exemple ! (négation) est l'opérateur booléen qui vous donne négatif (true pour false et vice versa) de cette valeur.
Et cette connaissance est en Javascript (et aussi PHP et Python) utilisé comme ceci:
var booleanValue = !!someVariable;
qui est dans votre cas:
!!(-1) //returns true
Alors oui, -1 convertira true par conversion javascript implicite.
En javascript, seul "0" est faux. Lorsque vous faites un appel avec un "!" Précédent, javascript va tout convertir en booléen. Autre fait intéressant:
console.log(!!!a); // false
console.log(!!!b); // true
Ainsi votre casting "a" à un booléen avec !! et obtenir la valeur inverse
-1 est une valeur semblable à trule. La seule valeur semblable à false entre les nombres dans JavaScript est 0. Autres false -comme les valeurs sont '', NaN, undefined ... J'espère que je n'ai rien manqué.
Lorsque vous utilisez indexOf tout ce que vous devez faire est
if (someString.indexOf('value') >= -1) {
//code if someString contains 'value'
}
Il est vrai (bien, "truthy").Le seul nombre "falsey" est zéro. Vous devez tester si '== -1' est vrai. – Blazemonger
Ce n'est ni un nombre, ni un booléen, mais c'est * vrai * – adeneo
Tout a commencé dans c où 0 était faux et tout le reste était vrai. JavaScript a essayé de suivre cela, mais il est devenu rapidement désordonné sans l'application stricte du type. – Hogan