Lógica Booleana

A lógica booleana é um sistema de lógica que lida com valores verdadeiros e falsos. Na programação, a lógica booleana é amplamente usada para tomar decisões e controlar o fluxo de um programa.

Os três principais operadores lógicos na lógica booleana são AND, OR e NOT.

• AND : O operador AND retorna verdadeiro somente se ambos os operandos forem verdadeiros.
• OU : O operador OU retorna verdadeiro se um ou ambos os operandos forem verdadeiros.
• NOT : O operador NOT retorna o oposto de um determinado operando.

Operadores Lógicos no Código

JavaScript tem três operadores lógicos: &&(AND), ||(OR) e !(NOT). Esses operadores costumam ser usados ​​para combinar e manipular valores booleanos em JavaScript.

Operador && (E)

O &&operador retorna truese ambos os operandos forem true, falsecaso contrário. aqui estão alguns exemplos:

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

// Type coercion examples
console.log("hello" && 42);   // 42
console.log("" && 42);       // ""

• O &&operador é conhecido como operador de curto-circuito porque avalia o segundo operando somente se o primeiro operando for verdadeiro. Isso pode ser útil para otimizar o código e evitar erros.

O ||operador retorna truese pelo menos um dos operandos for true, falsecaso contrário. aqui estão alguns exemplos:

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

// Type coercion examples
console.log("" || "hello");  // "hello"
console.log(0 || 42);        // 42

• O ||operador também é um operador de curto-circuito, avaliando o segundo operando somente se o primeiro operando for falso.
• O ||operador geralmente é usado para fornecer valores padrão para variáveis, como em const value = input || defaultValue;.

O !operador nega um valor booleano, retornando truese o operando for false, e falsese o operando for true. aqui estão alguns exemplos:

// Normal examples
console.log(!true);  // false
console.log(!false); // true

// Type coercion examples
console.log(!"hello");   // false
console.log(!undefined); // true

• O !operador pode ser usado para converter um valor em um tipo booleano negando-o duas vezes, como em !!value.

A Ordem dos Operadores Lógicos

A ordem dos operadores lógicos pode fazer diferença em alguns casos em que várias condições precisam ser avaliadas. aqui estão alguns exemplos:

Precedência do operador: o AND lógico ( &&) tem uma precedência maior do que o OR lógico ( ||). Isso significa que &&é avaliado antes ||e pode alterar o resultado de uma condição. Por exemplo:

// This condition will evaluate to true
if (true || false && true) {
  // do something
}
// This condition will evaluate to false
if ((true || false) && true) {
  // do something
}

No segundo exemplo, (true || false)é avaliado primeiro, o que resulta em true. Então true && trueé avaliado, o que resulta em true. A condição inteira também é verdadeira, mas é avaliada de forma diferente por causa dos parênteses.

Avaliação de curto-circuito: E lógico ( &&) e OU lógico ( ||) utilizam avaliação de curto-circuito, o que significa que o segundo operando só é avaliado se necessário. Por exemplo:

// This condition will evaluate to true without an error
if (x !== null && x.property === "value") {
  // do something
}
// This condition will throw an error
if (x.property === "value" && x !== null) {
  // do something
}

No segundo exemplo, if xis null, x.propertylançará um erro porque nullnão possui nenhuma propriedade. O segundo operando é avaliado antes do primeiro operando, o que pode levar a erros se não for usado com cuidado.

Negação: O NÃO lógico ( !) pode alterar o resultado de uma condição negando-a. Por exemplo:

let x = true;

// This condition will evaluate to false
if (!x) {
  // do something
}
// This condition will evaluate to true
if (!!x) {
  // do something
}

Como iniciante, é importante prestar atenção à ordem dos operadores lógicos e usar parênteses para esclarecer a ordem, se necessário. Também é importante entender a avaliação de curto-circuito e como ela pode evitar erros. A negação deve ser usada com cuidado porque pode tornar as condições mais difíceis de ler e entender.

Exemplos do mundo real

Aqui estão alguns exemplos realistas de operadores lógicos usados ​​no código. Leia os exemplos e veja se consegue entender a lógica, mas não desanime se não conseguir, pois ainda não discutimos as funções!

Validando a entrada do usuário:

function validateInput(input) {
  const isString = typeof input === 'string';
  const isNotEmpty = input !== '';
  const isLessThanTenChars = input.length < 10;
  return isString && isNotEmpty && isLessThanTenChars;
}

function filterProducts(products, minPrice, maxPrice, availableOnly) {
  return products.filter(product => {
    const isWithinPriceRange = product.price >= minPrice && product.price <= maxPrice;
    const isAvailable = availableOnly ? product.stock > 0 : true;
    return isWithinPriceRange && isAvailable;
  });
}

function isEligibleForDiscount(user) {
  const hasPaid = user.orders.some(order => order.status === 'paid');
  const hasFrequentOrders = user.orders.length >= 5;
  const hasValidCoupon = user.coupons.includes('DISCOUNT2022');
  return (hasPaid || hasFrequentOrders) && hasValidCoupon;
}

function isProductOnSale(product) {
  const isDiscounted = product.discount > 0;
  const hasLowStock = product.stock <= 10;
  return isDiscounted || hasLowStock;
}

function getTaskStatus(priority, isComplete) {
  const isUrgent = priority === 'high' || priority === 'urgent';
  const isOverdue = priority === 'low' && !isComplete;
  const isInProgress = priority === 'medium' && !isComplete;
   if (isUrgent) {
      return 'Urgent';
    } else if (isOverdue) {
      return 'Overdue';
    } else if (isInProgress) {
      return 'In Progress';
    } else {
      return 'Pending';
   }
}