Como !! ~ (não til / bang bang til) altera o resultado de uma chamada de método Array 'contém / incluído'?

Se você leu os comentários na inArraypágina jQuery aqui , há uma declaração interessante:

!!~jQuery.inArray(elm, arr) 

Agora, acredito que um ponto de exclamação duplo converterá o resultado em tipo boolean, com o valor de true. O que eu não entendo é qual é o uso do ~operador til ( ) em tudo isso?

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

Refatorando a ifdeclaração:

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

Demolir:

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

Também notei que se eu colocar o til na frente, o resultado é -2.

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

Não entendo o propósito do til aqui. Alguém pode me explicar ou indicar um recurso?

O operador til não faz parte do jQuery - é um operador NOT bit a bit no próprio JavaScript.

Veja O Grande Mistério do Til (~) .

Você está recebendo números estranhos em seus experimentos porque está realizando uma operação lógica bit a bit em um número inteiro (que, pelo que sei, pode ser armazenado como complemento de dois ou algo parecido ...)

O complemento de dois explica como representar um número em binário. Eu acho que estava certo.

Há um motivo específico que às vezes você verá ~aplicado antes $.inArray.

Basicamente,

~$.inArray("foo", bar)

é uma maneira mais curta de fazer

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

$.inArrayretorna o índice do item na matriz se o primeiro argumento for encontrado e retorna -1 se não for encontrado. Isso significa que se você estiver procurando por um booleano de "este valor está no array?", Você não pode fazer uma comparação booleana, pois -1 é um valor verdadeiro e quando $ .inArray retorna 0 (um valor falso ), significa que ele realmente foi encontrado no primeiro elemento da matriz.

A aplicação do ~operador bit a bit -1torna 0e faz com que 0 se torne `-1. Portanto, não encontrar o valor na matriz e aplicar o NOT bit a bit resulta em um valor falso (0), e todos os outros valores retornarão números diferentes de 0 e representarão um resultado verdadeiro.

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

E funcionará conforme o planejado.

!!~expravalia falsequando expré -1diferente true.
É o mesmo que expr != -1, apenas quebrado *

Funciona porque as operações bit a bit do JavaScript convertem os operandos em inteiros assinados de 32 bits no formato de complemento de dois. Assim, !!~-1é avaliado da seguinte forma:

   -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

Um valor diferente de -1terá pelo menos um bit definido como zero; invertê-lo criará um valor verdadeiro; aplicar o !operador duas vezes a um valor verdadeiro retorna verdadeiro booleano.

Quando usado com .indexOf()e queremos apenas verificar se o resultado é -1ou não:

!!~"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

* !!~8589934591avalia como falso, então esteabominaçãonão pode ser usado de forma confiável para testar -1.

~foo.indexOf(bar)é uma abreviatura comum de representar foo.contains(bar)porque a containsfunção não existe.

Normalmente, a conversão para booleano é desnecessária devido ao conceito de valores "falsos" do JavaScript. Nesse caso, é usado para forçar a saída da função a ser trueou false.

jQuery.inArray()retorna -1para "não encontrado", cujo complemento ( ~) é 0. Portanto, ~jQuery.inArray()retorna um valor falso ( 0) para "não encontrado" e um valor verdadeiro (um número inteiro negativo) para "encontrado". !!irá então formalizar o falso / verdadeiro em booleano real false/ true. Então, !!~jQuery.inArray()dará truepara "encontrado" e falsepara "não encontrado".

O ~para todos os 4 bytes inté igual a esta fórmula-(N+1)

TÃO

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

O ~operador é o operador de complemento bit a bit. O resultado inteiro de inArray()é -1, quando o elemento não é encontrado, ou algum inteiro não negativo. O complemento bit a bit de -1 (representado em binário como todos os bits 1) é zero. O complemento bit a bit de qualquer inteiro não negativo é sempre diferente de zero.

Assim, !!~iserá truequando o inteiro "i" for um inteiro não negativo e falsequando "i" for exatamente -1.

Observe que ~sempre coage seu operando para inteiro; isto é, ele força valores de ponto flutuante não inteiros para inteiros, bem como valores não numéricos.

Til NÃO é bit a bit - ele inverte cada bit do valor. Como regra geral, se você usar ~em um número, seu sinal será invertido e, em seguida, 1 será subtraído.

Portanto, ao fazer isso ~0, você obtém -1 (0 invertido é -0, subtrair 1 é -1).

É essencialmente uma maneira elaborada e supermicrotimizada de obter um valor que é sempre booleano.

Você está certo: Este código retornará falsequando a indexOfchamada retornar -1; caso contrário true.

Como você disse, seria muito mais sensato usar algo como

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

O ~operador é o operador NOT bit a bit. O que isso significa é que ele pega um número na forma binária e transforma todos os zeros em uns e os uns em zeros.

Por exemplo, o número 0 em binário é 0000000, enquanto -1 é 11111111. Da mesma forma, 1 está 00000001em binário, enquanto -2 está 11111110.

Meu palpite é que está lá porque tem alguns caracteres mais curtos (o que os autores da biblioteca sempre buscam). Ele também usa operações que levam apenas alguns ciclos de máquina quando compiladas no código nativo (em oposição à comparação com um número).

Concordo com outra resposta de que é um exagero, mas talvez possa fazer sentido em um ciclo restrito (requer estimativa de ganho de desempenho, caso contrário, pode acabar sendo uma otimização prematura).

Suponho que, por ser uma operação bit a bit, é a maneira mais rápida (computacionalmente barata) de verificar se o caminho aparece emmodedPaths.

Como (~(-1)) === 0, então:

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