the - operador ternario multiple javascript

Logical NOT on Boolean Object siempre devuelve false en Javascript

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Por qué! Nuevo booleano (falso) es falso en JavaScript? 2 respuestas

¿Por qué el operador lógico no en javascript devuelve un resultado diferente entre el valor booleano y el objeto booleano ? Considere el siguiente ejemplo.

!true  // false
!false // true

!(new Boolean(true))  // false
!(new Boolean(false)) // false

De la especificación , dice que el valor que se está evaluando se convirtió en ToBoolean . ToBoolean devolverá verdadero si el argumento es un Objeto, y devolverá tal como está si el argumento es un Booleano.

Examinando aún más, ToBoolean también se usa en otros lugares como la instrucción if y el operador condicional, considere el siguiente ejemplo:

var a = (new Boolean(false)) ? "unexpected" : "expected";
console.log(a); // unexpected

La pregunta: ¿es un objeto booleano un objeto o un booleano? ¿No deberíamos evaluar el objeto booleano como booleano?

ACTUALIZAR

Mi pregunta fue marcada como pregunta duplicada con esto . Esa pregunta no tiene respuestas satisfactorias porque ninguna responde a mi pregunta: ¿el objeto booleano es un objeto o un booleano? ¿No deberíamos evaluar el objeto booleano como booleano?

El simple hecho de saber que un objeto booleano es un objeto no es suficiente, ¿por qué existe incluso y cuál es la forma correcta de tratar y / o diseñar objetos con un objeto booleano que aún no se ha respondido?

Answer 1

Un object , no importa si tiene propiedades o no, nunca es false por defecto ...

new Boolean(true) devolverá un object no Boolean y !{} siempre será false ya que {} es un valor truthy ( Boolean({}) se evaluará como true )

Al tratar con Boolean función de fábrica Boolean , no cree una nueva instancia usando la new (ya que creará una nueva instancia de Boolean y devolverá un object )

Boolean(INPUT) devolverá primitive-Boolean valor primitive-Boolean de la expression especificada que podría usarse para la comparison

De los documentos, el objeto booleano es un envoltorio de objeto para un boolean value ()

Descripción: el valor pasado como primer parámetro se convierte a un valor boolean , si es necesario. Si el valor se omite o es 0, -0, null, false, NaN, undefined, or the empty string ("") , el objeto tiene un valor inicial de false . Todos los demás valores, incluido cualquier objeto o la cadena "falsa", crean un objeto con un valor inicial de true .

No confunda los valores booleanos primitivos verdaderos y falsos con los valores verdaderos y falsos del objeto booleano.

Cualquier objeto cuyo valor no sea undefined o null , incluido un Boolean object cuyo valor es falso, se evalúa como true "cuando se pasa a una declaración condicional". [ Reference ]

Por ejemplo, la condición en la siguiente instrucción if se evalúa como true

var x = new Boolean("false");
if (x) {
  console.log(''x is true'');
}

var y = new Boolean(false);
if (y) {
  console.log(''y is true'');
}

<script src="http://gh-canon.github.io/stack-snippet-console/console.min.js"></script>

Answer 2

Acabo de probar el siguiente:

            alert(typeof true);    //alerts boolean
            alert(typeof new Boolean(true));   //alert object
            alert(typeof !(new Boolean(true)));   //alerts boolean
            alert(!(new Boolean(true)));         //alerts false

Tanto Rayon como Mukul tienen razón, solo necesitas usar !Boolean(false) // devuelve true como un valor booleano.

Answer 3

De Reference :

Cualquier objeto cuyo valor no sea indefinido o nulo, incluido un objeto booleano cuyo valor es falso, se evalúa como verdadero cuando se pasa a una declaración condicional.

Por ejemplo, la condición en la siguiente instrucción if se evalúa como verdadera:

  var x = new Boolean("false");
  if (x) {
    // this code is executed
  }

  var y = new Boolean(false);
  if (y) {
    // this code is also executed
  }

Answer 4

Obtendrá el mismo resultado para los parámetros true y false cuando use un new Boolean(...)

Libro de JavaScript orientado a objetos, Stoyan Stefanov:

Puede convertir cualquier valor a su equivalente booleano utilizando una doble negación. Comprender cómo cualquier valor se convierte en un booleano es importante. La mayoría de los valores se convierten a verdadero con la excepción de lo siguiente, que se convierte a falso

""
nulo
indefinido
0
Yaya
falso

Entonces !!{} , !!new Boolean(true) , !!new Boolean(false) return siempre true

Esta condición (sin doble negación):

if (new Boolean(true) === true) {

    console.log(''this string will never be printed'');
}

devuelve false , porque hay diferentes tipos:

typeof new Boolean(true); // "object"
typeof true; // "boolean"

Debe compararlos solo por valor para obtener un resultado esperado:

if (new Boolean(true) == true) {

    console.log(''Yay!'');
}

new Boolean(true) == true; // true
new Boolean(true) === true; // false

Otro ejemplo:

if (new Boolean(true) === new Boolean(true)) {

    console.log(''this string will never be printed'')
}

En este caso estás intentando comparar objetos. Obtendrá el mismo resultado con los operadores de comparación == y === .

Libro de JavaScript orientado a objetos, Stoyan Stefanov:

Cuando compara objetos, obtendrá verdadero solo si compara dos referencias al mismo objeto. La comparación de dos objetos distintos que tienen exactamente los mismos métodos y propiedades devuelve falso.

No utilice un objeto booleano new Boolean(...) en lugar de un primitivo booleano.

Answer 5

Boolean es una función. Dependiendo del tipo de invocación, tiene un comportamiento diferente en términos de truthy y falsy .

1. Invocando como una simple función.

Al llamar a Boolean(value) como una función simple, verifica si el argumento es false ( false , null , undefined , '''' , 0 , Nan ) o truthy (todos los demás valores: instancias de objeto, 1 , true , etc.). Este tipo de invocación devuelve un tipo primitivo booleano .
Funciona como se espera:

Boolean(null) // prints false
Boolean(0)    // prints false

Boolean({})  // prints true
Boolean(-1)  // prints true

2. Invocando como constructor.

Como cualquier función en JavaScript, Boolean puede invocarse como constructor: var b = new Boolean(value) . Este tipo de invocación devuelve una Reference .
Esto introduce confuso porque JavaScript trata las instancias de objetos como truthy valor truthy .

var b = new Boolean(null);

!!b // prints true, because b is an object instance

if (b) { // b evaluates to true
   //executed code 
}

2.1 ¿Por qué invocar como constructor es posible?

JavaScript permite que esta invocación del constructor proporcione al desarrollador un mecanismo para preservar la creación de propiedades para un boolean . Un tipo booleano primitivo no guarda las propiedades asignadas a él.

var booleanObject = new Boolean(null);
booleanObject.foo = ''bar''; // create a property
booleanObject.foo // prints ''bar''

var booleanPrimitive = false;
booleanPrimitive.foo = ''bar''; // create a property
booleanPrimitive.foo // prints undefined

2.2 Cómo hacer que el objeto booleano funcione

Sin embargo, el new Boolean(value) tiene un mecanismo para hacer comparación. Al igual que cualquier objeto de JavaScript, tiene un método valueOf() , que devuelve la transformación del value a un tipo primitivo booleano ( true para truey y false para falsy):

var falsyBoolean = new Boolean(null);
falsyBoolean.valueOf() // prints false, because null is falsy

var truthyBoolean = new Boolean(1);
truthyBoolean.valueOf() // prints true, because 1 is truthy

Para hacer que esto funcione en condiciones, es necesario evitar cualquier transformación de la instancia del objeto booleano en un valor verdadero. Para que esto suceda, use el operador de comparación == directamente:

var falsyBoolean = new Boolean(null);

falsyBoolean == false ? ''falsy'' : ''truthy'' // prints expected ''falsy''

if (falsyBoolean == false) { 
  //executed code
}

Si un operando en == operador es un objeto y otro tipo primitivo, JavaScript lo transforma en un tipo primitivo, que en realidad consiste en llamar al método valueOf() en el objeto booleano. Ver más detalles en este artículo .

3. ¿Cómo no confundirse?

La mejor regla es evitar usar Boolean como instancias de objetos. Boolean(value) o !!value es suficiente para verificar el estado de verdad variable.