javascript - rae - signo de interrogacion inicial

¿Doble signo de exclamación?

Question

Posible duplicado:
Cuál es el !! (no no) operador en JavaScript?
Lo que hace el !! significa operador (doble signo de exclamación) en JavaScript?

Así que estaba depurando un código y encontré esto:

var foo.bar = 0; // this is actually passed from another function, adding it for context

function(foo)
    var someVar = !!foo.bar;
    if(foo.bar){
      // ..stuff happens
    }
    else{
      // .. something else happens
    }
}

De acuerdo, mi pregunta es ¿de qué sirve? Todo lo que está haciendo es hacer que 0 === false .

1. ¿Hay algún beneficio en usar eso en comparación con boolean(foo.bar) ?

2. foo.bar se puede evaluar en un si como está porque 0 === false ya, entonces ¿por qué pasar por la conversión? (someVar no se reutiliza en ningún otro lugar)

Answer 1

Como se indicó anteriormente, fuerza a un objeto con un tipo booleano. Puedes verlo por ti mismo:

(function typecheck() {
  var a = "a";
  var b = !a;
  var c = !!a;

  alert("var a = " + typeof(a) + "/n" +
        "var b = " + typeof(b) + "/n" +
        "var c = " + typeof(c));
})();

Si simplemente hace comparaciones, la conversión simplemente le ahorra una coerción de tipo más adelante.

FYI, los siguientes valores son coercionados a FALSE en JavaScript:

• falso
• 0
• ""
• nulo
• indefinido

Answer 2

Creo que la respuesta es que realmente no tiene mucho sentido. Podemos especular acerca de cómo sucedió:

• tal vez una versión anterior de la función usó algunos someVar en múltiples lugares, o en formas que realmente se beneficiaron de tener true o false , por lo que esto tenía más sentido.
• ¡tal vez la persona que escribió la función está tan acostumbrada a usarla !! convertir a true / false que (s) él ni siquiera notó que no era necesario aquí.
• tal vez la persona que escribió la función siente que a cada cálculo (en este caso, conversión booleana) se le debe dar un nombre significativo asignando alguna variable a su resultado.
• tal vez, dado que la conversión booleana en JavaScript es sorprendentemente propensa a errores (en eso, por ejemplo, new Boolean(false) es un valor verdadero), la persona que escribió la función siente que siempre debe hacerse explícitamente en lugar de implícitamente, aunque el el efecto es el mismo, solo para llamar la atención como posible punto de error.
  • ¡esto, por supuesto, presupone que la persona que escribió la función piensa !! como una conversión booleana "explícita". Técnicamente no lo es - usa la misma conversión Booleana implícita que if hace - pero si estás acostumbrado a este modismo, entonces equivale a una conversión explícita.

pero en mi opinión subjetiva, ninguno de esos motivos es muy bueno.

Answer 3

Esto convierte un valor en booleano y asegura un tipo booleano .

"foo"      =    "foo"
!"foo"     =    false
!!"foo"    =    true

Si se pasa foo.bar , entonces puede no ser 0, sino algún otro valor falso. Ver la siguiente tabla de verdad:

Truth Table para javascript

''''        ==   ''0''           // false
0         ==   ''''            // true
0         ==   ''0''           // true
false     ==   ''false''       // false
false     ==   ''0''           // true
false     ==   undefined     // false
false     ==   null          // false
null      ==   undefined     // true
" /t/r/n" ==   0             // true

Fuente: Doug Crockford

Javascript también se vuelve realmente extraño cuando se trata de valores NaN. ¡Y este es el único caso en el que puedo pensar en la parte superior de mi cabeza! se comportaría de manera diferente a ===.

NaN   ===  NaN     //false
!!NaN === !!NaN    //true

// !!NaN is false