Comment !! ~ (pas tilde / bang bang tilde) modifie-t-il le résultat d'un appel à la méthode Array 'contient / inclus'?

Si vous lisez les commentaires sur la inArraypage jQuery ici , il y a une déclaration intéressante:

!!~jQuery.inArray(elm, arr) 

Maintenant, je crois qu'un point d'exclamation double convertira le résultat en type boolean, avec la valeur de true. Ce que je ne comprends pas, c'est à quoi sert l' ~opérateur tilde ( ) dans tout cela?

var arr = ["one", "two", "three"];
if (jQuery.inArray("one", arr) > -1) { alert("Found"); }

Refactorisation de l' ifinstruction:

if (!!~jQuery.inArray("one", arr)) { alert("Found"); }

Panne:

jQuery.inArray("one", arr)     // 0
~jQuery.inArray("one", arr)    // -1 (why?)
!~jQuery.inArray("one", arr)   // false
!!~jQuery.inArray("one", arr)  // true

J'ai aussi remarqué que si je mets le tilde devant, le résultat est -2.

~!!~jQuery.inArray("one", arr) // -2

Je ne comprends pas le but du tilde ici. Quelqu'un peut-il l'expliquer ou me diriger vers une ressource?

L'opérateur tilde ne fait pas du tout partie de jQuery - c'est un opérateur NOT au niveau du bit dans JavaScript lui-même.

Voir Le grand mystère du tilde (~) .

Vous obtenez des nombres étranges dans vos expériences parce que vous effectuez une opération logique au niveau du bit sur un entier (qui, pour autant que je sache, peut être stocké en tant que complément à deux ou quelque chose comme ça ...)

Le complément à deux explique comment représenter un nombre en binaire. Je pense que j'avais raison.

Il y a une raison spécifique que vous verrez parfois ~appliquée devant $.inArray.

Fondamentalement,

~$.inArray("foo", bar)

est une façon plus courte de faire

$.inArray("foo", bar) !== -1

$.inArrayrenvoie l'index de l'élément dans le tableau si le premier argument est trouvé, et il renvoie -1 s'il n'est pas trouvé. Cela signifie que si vous recherchez un booléen de "cette valeur est-elle dans le tableau?", Vous ne pouvez pas faire de comparaison booléenne, car -1 est une valeur vraie, et quand $ .inArray renvoie 0 (une valeur falsifiée ), cela signifie qu'il se trouve réellement dans le premier élément du tableau.

L'application de l' ~opérateur -1au niveau du bit fait devenir 0et fait passer 0 à `-1. Ainsi, ne pas trouver la valeur dans le tableau et appliquer le NOT au niveau du bit entraîne une valeur fausse (0), et toutes les autres valeurs renverront des nombres non-0 et représenteront un résultat véridique.

if (~$.inArray("foo", ["foo",2,3])) {
    // Will run
}

Et cela fonctionnera comme prévu.

!!~exprévalue falsequand exprest -1autrement true.
C'est la même chose que expr != -1, seulement cassé *

Cela fonctionne car les opérations JavaScript au niveau du bit convertissent les opérandes en entiers signés 32 bits au format complément à deux. Ainsi !!~-1est évalué comme suit:

   -1 = 1111 1111 1111 1111 1111 1111 1111 1111b // two's complement representation of -1
  ~-1 = 0000 0000 0000 0000 0000 0000 0000 0000b // ~ is bitwise not (invert all bits)
   !0 = true                                     // ! is logical not (true for falsy)
!true = false                                    // duh

Une valeur autre que -1aura au moins un bit mis à zéro; l'inverser créera une valeur de vérité; appliquer l' !opérateur deux fois à une valeur de vérité renvoie la valeur booléenne true.

Lorsqu'il est utilisé avec .indexOf()et nous voulons seulement vérifier si le résultat est -1ou non:

!!~"abc".indexOf("d") // indexOf() returns -1, the expression evaluates to false
!!~"abc".indexOf("a") // indexOf() returns  0, the expression evaluates to true
!!~"abc".indexOf("b") // indexOf() returns  1, the expression evaluates to true

* !!~8589934591évalue à faux donc ceciabominationne peut pas être utilisé de manière fiable pour tester -1.

~foo.indexOf(bar)est un raccourci courant à représenter foo.contains(bar)car la containsfonction n'existe pas.

En général, la conversion en booléen n'est pas nécessaire en raison du concept JavaScript de valeurs "fausses". Dans ce cas, il est utilisé pour forcer la sortie de la fonction à être trueou false.

jQuery.inArray()renvoie -1"non trouvé", dont le complément ( ~) est 0. Ainsi, ~jQuery.inArray()renvoie une valeur falsifiée ( 0) pour "not found", et une valeur de vérité (un entier négatif) pour "found". !!formalisera alors le faux / véridique en vrai booléen false/ true. Donc, !!~jQuery.inArray()donnera truepour "trouvé" et falsepour "non trouvé".

Le ~pour tous les 4 octets intest égal à cette formule-(N+1)

ALORS

~0   = -(0+1)   // -1
~35  = -(35+1)  // -36 
~-35 = -(-35+1) //34 

L' ~opérateur est l'opérateur de complément au niveau du bit. Le résultat entier de inArray()est soit -1, lorsque l'élément n'est pas trouvé, soit un entier non négatif. Le complément bit à bit de -1 (représenté en binaire comme les 1 bits) est zéro. Le complément binaire de tout entier non négatif est toujours différent de zéro.

Ainsi, !!~isera truelorsque l'entier "i" est un entier non négatif, et falselorsque "i" est exactement -1.

Notez que ~contraint toujours son opérande à un entier; c'est-à-dire qu'il force les valeurs à virgule flottante non entières à des nombres entiers, ainsi que des valeurs non numériques.

Tilde n'est PAS au niveau du bit - il inverse chaque bit de la valeur. En règle générale, si vous utilisez ~sur un nombre, son signe sera inversé, puis 1 sera soustrait.

Ainsi, lorsque vous le faites ~0, vous obtenez -1 (0 inversé est -0, soustrayez 1 est -1).

C'est essentiellement une manière élaborée et ultra-micro-optimisée d'obtenir une valeur toujours booléenne.

Vous avez raison: ce code sera renvoyé falselorsque l' indexOfappel renvoie -1; autrement true.

Comme vous le dites, il serait beaucoup plus judicieux d'utiliser quelque chose comme

return this.modifiedPaths.indexOf(path) !== -1;

L' ~opérateur est l'opérateur NOT au niveau du bit. Cela signifie qu'il prend un nombre sous forme binaire et transforme tous les zéros en uns et les uns en zéros.

Par exemple, le nombre 0 en binaire est 0000000, tandis que -1 l'est 11111111. De même, 1 est 00000001en binaire, tandis que -2 est 11111110.

Je suppose que c'est là parce que c'est quelques caractères plus courts (quels auteurs de bibliothèque recherchent toujours). Il utilise également des opérations qui ne prennent que quelques cycles machine lorsqu'elles sont compilées dans le code natif (par opposition à la comparaison à un nombre).

Je suis d'accord avec une autre réponse selon laquelle c'est exagéré, mais cela pourrait peut-être avoir du sens dans une boucle serrée (nécessite une estimation du gain de performance, cependant, sinon peut s'avérer être une optimisation prématurée.)

Je suppose que, puisqu'il s'agit d'une opération au niveau du bit, c'est le moyen le plus rapide (peu coûteux en calcul) de vérifier si le chemin apparaît dans modifiedPaths.

Comme (~(-1)) === 0, donc:

!!(~(-1)) === Boolean(~(-1)) === Boolean(0) === false