Explicar la coerción de valor no booleano a uno booleano en JavaScript

Como todos sabemos, javascript es un lenguaje indulgente. No le importan los errores tontos que cometen los programadores. Entonces, a veces da resultados inesperados. Entonces siente que Javascript dice «Puedo hacer todas las posibilidades».

La coerción es una de esas en las que javascript da resultados extraños porque javascript realiza automáticamente la conversión de tipo en la que los primeros valores se convierten en otros tipos de datos (string, número, objeto, etc.) y luego da resultado. Cualquier tipo, ya sea primitivo (string, booleano, número, nulo, indefinido, símbolo) o no primitivo (objeto, array, registro exp) es válido.

Comprendamos cómo funciona Coerción para diferentes operaciones de tipos de datos.

Ejemplo:

<script>
    if([]+"A")
    console.log([]+5);
    console.log("1"+2);
    if(true)
    console.log(false)
    console.log({ }+{ });
</script>

Producción: 

Explicación: Aquí, para la primera declaración, el primer operando [] es un objeto y el otro es una string, por lo que ambos se combinan como una string y se aplica la misma lógica en la declaración interna si aquí también ambos se coaccionan a una string. para una segunda declaración if verdadera primero forzada a 1, luego si el bloque ejecuta el último ejemplo {} + {}, aquí ambos objetos se concatenan como un objeto.

Booleano: una entidad lógica con valores como ‘verdadero’ y ‘falso’. 

Para la conversión booleana hay dos formas:

1. !!: ¡Primero ! convirtió o coaccionó el valor a booleano opuesto al valor dado y luego usando doble (!!) da booleano.
2. Boolean(): simplemente forzó el valor al valor booleano deseado.

Ejemplo :

<script>
    // Boolean converted true first to 1
    // then it gives output true
    console.log(Boolean(true)) //true
 
    // String is constant variable storing string value
    const string = 'string';
     
    // y is constant variable coerced boolean
    // to constant variable string
    const y=!!string;
    console.log(y) //true
     
    // Here !(single exclamatory) on constant variable
    // y coerced true value to false.
    console.log(!y) //false
 
    // a is constant variable storing integer value
    const a=34
     
    // x is constant variable coerced boolean to
    // constant variable a
    const x=Boolean(34);
    console.log(x) //true
</script>

Producción:

true
true
false
true

Hay dos tipos de coerción:

1. Coerción de tipo implícita: Javascript en sí mismo realiza la conversión a otro tipo de datos automáticamente para proporcionar resultados según las necesidades del desarrollador.
2. Coerción de tipo explícito: el desarrollador o programador da el tipo explícitamente o dice encasillamiento.

Ejemplo:  

<script>
    // Implicit coercion
    console.log(typeof(5/null));
    console.log(typeof('2'== 2));
 
    // Explicit coercion
    const num = "124789";
    const a = Number(num);
    console.log(typeof(a));
    const b = 0 | null
    console.log(typeof(b))
</script>

Producción:

number
boolean
number
number

Valores falsos: los valores que se convierten en booleanos siempre dan un resultado verdadero.

Hay seis valores falsos en javascript:

1. falso
2. indefinido
3. nulo
4. NaN (No es un número)
5. 0
6. » » (cuerda vacía)

Ejemplo:

<script>
    // Boolean conversion of empty string
    console.log(!!"");         // false
     
    // Boolean conversion of 0
    console.log(!!0);          // false
     
    // Boolean conversion of null
    console.log(Boolean(null));       // false
     
    // Boolean conversion of undefined
    console.log(Boolean(undefined));  // false
     
    // Opposite of boolean conversion
    // (true to false using single !) of not a number
    console.log(Boolean(!NaN));        // true
     
    // Boolean conversion of false
    console.log(!!false);      //false
</script>

Producción:

false
false
false
false
true
false

¿Dónde no funciona la coerción en javascript al convertir booleano?

El operador de comparación (===) se conoce como operador de igualdad estricta . (===) la coerción no funciona y (==) para esto funciona. Comprueba tanto el tipo de datos como el contenido. Si el tipo de datos no es igual, devuelve falso. Entonces «1» === 1 ahora se evalúa como falso. Da resultados según el tipo, activa la coerción de tipo implícita.

Nota: Todos los ejemplos anteriores se pueden probar escribiéndolos dentro de la etiqueta de script de HTML o usando la consola.