Introducción

Los valores booleanos son absolutos, verdaderos o falsos. Eso es lo más claro posible. Otros tipos de datos en JavaScript también tienen estos valores inherentes de verdadero y falso, pero no es tan obvio porque parecen 32, nulo, 0 y "Hola" en lugar de verdadero y falso. Saber que todos los valores tienen estos valores inherentes significa que podemos realizar operaciones en todos los tipos de datos que normalmente se usan para los booleanos. Esto nos proporciona más creatividad y flexibilidad al codificar.

Comprender los valores de verdad y falsedad

Cuando trabajamos con palabras clave de flujo de control como if y operadores lógicos como AND (&&) y OR (||), utilizamos valores booleanos para lograr ciertos resultados. Estos booleanos se pueden usar explícitamente con verdadero o falso, pero a menudo los generamos con operadores de comparación como ===, .

¿Qué pasa si no utilizamos un booleano con flujo de control u operadores lógicos? Bueno, ¡estás de suerte! Todos los valores son inherentemente verdaderos o falsos para ayudar con esto. Podemos clasificar todos los valores en dos categorías: verdadero o falso.

Al intentar determinar si un valor es verdadero o falso, es mejor recordar los valores falso ya que solo hay una cantidad limitada de ellos:

• falso (un valor booleano)
• nulo
• indefinido
• NaN (no es un número)
• 0 (un valor numérico)
• "" (el valor de cadena vacía)

Todo lo demás es verdad. Si no está seguro de si algo es verdadero o falso o se encuentra con una situación única que parece ambigua, siempre puede crear una declaración if para ver si se ejecuta el código dentro del siguiente bloque de código.

if (23) { console.log(“truthy”); } // Prints “truthy”
else { console.log(“falsy”); }

if (null) { console.log(“truthy”); } 
else { console.log(“falsy”); } // Prints “falsy”

Y lógico (&&)

Cuando se utilizan valores booleanos con el AND lógico (&&), ambos valores deben ser verdaderos para que el operador lógico devuelva verdadero. De lo contrario, si al menos un valor es falso, devolverá falso.

console.log(false && false); // false
console.log(true && false); // false
console.log(true && true); // true

Comprender la mecánica del operador lógico AND (&&) puede ayudarle cuando se trata de valores verdaderos y falsos. Si el valor de la izquierda es falso, devuélvalo; de lo contrario, devuelve el valor de la derecha.

console.log(0 && 1); // 0
console.log("a" && ""); // "" (an empty string)
console.log([] && [1, 2, 3]); // [1, 2, 3]

El operador lógico AND (&&) quiere devolver un valor falso y solo devuelve el valor verdadero a la derecha si ambos son verdaderos. Puedes pensar en los dos argumentos así:

(Lado izquierdo) Úsame solo si tengo un valor falso. && (Lado derecho) De lo contrario, úsame.

O lógico (||)

Cuando se utilizan valores booleanos con el OR lógico (||), ambos valores deben ser falsos para que el operador lógico devuelva falso. De lo contrario, si al menos un valor es verdadero, devolverá verdadero.

console.log(false || false); // false
console.log(true || false); // true
console.log(true || true); // true

Así es como funciona el operador lógico OR (||): si el valor de la izquierda es verdadero, lo devuelve; de lo contrario, devuelve el valor de la derecha.

console.log(1 || 0); // 1
console.log("" || "a"); // "a"
console.log(undefined || null); // null
console.log([] || [1, 2, 3]); // []

El operador lógico OR (||) quiere devolver un valor verdadero y solo devuelve el valor falso de la derecha si ambos son falsos. Puedes pensar en los dos argumentos así:

(Lado izquierdo) Úsame sólo si soy un valor veraz. || (Lado derecho) De lo contrario, úsame.

Usos creativos de AND (&&) y OR (||)

Usar un valor predeterminado cuando se espera una entrada

Digamos que estás creando un objeto que representa a una persona y que viene con propiedades que describen a la persona junto con una función que saluda a los demás usando las otras propiedades del objeto.

function Person(name) {
    // If name is undefined, this.name will 
    // default to 'a person with no name'
    this.name = name || 'a person with no name';
    this.greet = function() {
        console.log('Hello, I am '   this.name   '.');
    };
}

// Create Person variables
var tyler = new Person('Tyler');
var mystery = new Person(); 
// Without an input, this.name defaults to the 
// second option since name is undefined.

// Call greet() from each Person object
tyler.greet(); // "Hello, I am Tyler."
mystery.greet(); // "Hello, I am a person with no name."

En el ejemplo anterior, esperábamos una entrada para el parámetro de nombre, por lo que el segundo valor en la operación OR (||) solo se usa si el nombre no está definido (sin argumento en la llamada a la función).

Requerir múltiples entradas

Si está creando objetos y desea asegurarse de tener una cantidad determinada de entradas antes de crear el objeto, puede encadenar operadores lógicos AND (&&) en cada parámetro requerido.

function Person(firstName, lastName, age) {
  if (firstName && lastName && age) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.fullName = `${this.firstName} ${this.lastName}`;
    this.age = age;
    this.greet = function() {
      console.log(`Hello, my name is ${this.fullName} and I'm ${this.age} years old.`);
    };
  } 

  // If any argument is missing, the object will only have this property.
  else {
    this.greet = function() {
      console.log(`Hello, I am not a fully formed Person.`)
    };
  }
}

var tyler = new Person('Tyler', 'Meyer', 32);
var brad = new Person('Brad', '', 38);

tyler.greet(); // "Hello, my name is Tyler Meyer and I'm 32 years old."
brad.greet(); // "Hello, I am not a fully formed Person."

La declaración if busca un argumento para cada parámetro antes de crear el objeto Persona completo. Si incluso un argumento es un valor falso, creará un objeto con la declaración else. Por lo tanto, podemos evitar objetos incompletos o crear objetos predeterminados para entradas incompletas.

Conclusión

Si necesita un valor predeterminado hasta que se proporcione un valor, el operador lógico OR (||) puede resultar muy útil. Si necesita solicitar varios valores antes de continuar, el operador lógico AND (&&) puede resultar muy útil. Estos son sólo dos ejemplos y, a medida que continúe explorando estos operadores, descubrirá que hay muchas más formas de utilizarlos además de la comprobación habitual de valores booleanos verdaderos o falsos. Tenga en cuenta estas dos cosas cuando considere usar los lógicos AND (&&) y OR (||):

• O (||): solo use el valor de la izquierda si es verdadero.
• Y (&&): solo use el valor de la izquierda si es falso.

Si tienes alguna pregunta, déjala en los comentarios. Estaré encantado de seguir discutiendo este tema.

¡Feliz codificación!