switch - Cuándo usar el operador double not(!!) en JavaScript

ternary operator javascript

Question

Entiendo lo que hace el operador no doble en JavaScript . Tengo curiosidad sobre su uso y si una afirmación reciente que hice es correcta o no.

Dije que if (!!someVar) nunca es significativo ni lo es (!!someVar && ... porque tanto el if como el && provocarán que someVar se evalúe como un booleano, por lo que !! es superfluo.

De hecho, el único momento en que pude pensar que sería legítimo usar el operador de doble no es si quería hacer una comparación estricta con otro valor booleano (así que tal vez en un valor de retorno que espere verdadero o falso explícitamente).

¿Es esto correcto? Empecé a dudar de mí mismo cuando noté que jQuery 1.3.2 usaba tanto if (!!someVar) como return !!someVar && ...

¿El doble no tiene ningún efecto real en estas situaciones?

Mi opinión personal es que solo conduce a la confusión. Si veo una instrucción if, sé que la está evaluando como booleana.

Answer 1

En el contexto de las declaraciones ToBoolean que estoy con usted, es completamente seguro porque, internamente, la operación ToBoolean se ejecutará en la expresión de condición ( consulte el Paso 3 de la especificación ).

Pero si quiere, digamos, devolver un valor booleano de una función, debe asegurarse de que el resultado sea realmente booleano, por ejemplo:

function isFoo () {
  return 0 && true;
}

console.log(isFoo()); // will show zero
typeof isFoo() == "number";

En conclusión, los operadores lógicos booleanos pueden devolver un operando , y no necesariamente un resultado Boolean :

El operador lógico Y ( && ) devolverá el valor del segundo operando si el primero es verdadero :

true && "foo"; // "foo"

Y devolverá el valor del primer operando si es falso por sí mismo :

NaN && "anything"; // NaN
0 && "anything"; // 0

Por otro lado, el operador lógico O ( || ) devolverá el valor del segundo operando , si el primero es falso :

false || "bar"; // "bar"

Y devolverá el valor del primer operando si es por sí mismo no falso:

"foo" || "anything"; // "foo"

Quizás vale la pena mencionar que los valores falsy son: null , undefined , NaN , 0 , cadena de longitud cero, y por supuesto false .

Cualquier otra cosa (que no sea falsy , un objeto Boolean o un valor Boolean ), evaluada en contexto booleano , devolverá true .

Answer 2

Sí, !! var se usa cuando quiere 0 || 1 valor de retorno.

Una es la simple comparación de los valores de bool, cuando se quiere que "a == b" sea equivalente a "a xor not b", excepto a = 5 y b = 7 ambos serían verdaderos pero no iguales.

Otro es cuando se quiere forzar un conjunto de condiciones en bits de una variable:

 var BIT_NONEMPTY=1;
 var BIT_HASERRORS=2;
 var BIT_HASCHILDREN=4;
 var BIT_HASCONTENT=8;

 result_bitfields = 
    (!!countLines())*BIT_NOTEMPTY +
    (!!errorCode())*BIT_HASERRORS +
    (!!firstChild())*BIT_HASCHILDREN +
    (!!getContent())*BIT_HASCONTENT;

No es muy útil en Javascript, que vive bastante lejos de los valores de bit, pero puede ser útil a veces.