Comparteix a través de

Operadores lógicos booleanos: AND, OR, NOT, XOR

  • Article

Los operadores booleanos lógicos realizan operaciones lógicas con operandos bool. Los operadores incluyen la negación lógica unaria (!), AND lógico binario (&), OR (|) y OR exclusivo (^) y los AND (&&) y OR (||) lógicos condicionales binarios.

En el caso de los operandos de los tipos numéricos enteros, los operadores &, | y ^ realizan operaciones lógicas bit a bit. Para obtener más información, vea Operadores de desplazamiento y bit a bit.

Operador de negación lógico !

El operador ! de prefijo unario calcula la negación lógica de su operando. Es decir, genera true, si el operando se evalúa como false, y false, si el operando se evalúa como true:

bool passed = false;
Console.WriteLine(!passed);  // output: True
Console.WriteLine(!true);    // output: False

El operador ! de postfijo unario es un operador que permite un valor NULL.

Operador lógico AND &

El operador & calcula el operador AND lógico de sus operandos. El resultado de x & y es true si x y y se evalúan como true. De lo contrario, el resultado es false.

El operador & siempre evalúa ambos operandos. Cuando el operando izquierdo se evalúa como false, el resultado de la operación es false independientemente del valor del operando derecho. Sin embargo, incluso después, se evalúa el operando derecho.

En el ejemplo siguiente, el operando derecho del operador & es una llamada de método, que se realiza independientemente del valor del operando izquierdo:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

El operador AND lógico condicional && también calcula el operador AND lógico de sus operandos, pero no evalúa el operando derecho si el izquierdo se evalúa como false.

En el caso de los operandos de los tipos numéricos enteros, el operador & calcula el AND lógico bit a bit de sus operandos. El operador & unario es el operador address-of.

Operador IR exclusivo lógico ^

El operador ^ calcula el operador OR exclusivo lógica, también conocido como el operador XOR lógico, de sus operandos. El resultado de x ^ y es true si x se evalúa como true y y se evalúa como false o x se evalúa como false y y se evalúa como true. De lo contrario, el resultado es false. Es decir, en los operandos bool, el operador ^ calcula el mismo resultado como el operador de desigualdad !=.

Console.WriteLine(true ^ true);    // output: False
Console.WriteLine(true ^ false);   // output: True
Console.WriteLine(false ^ true);   // output: True
Console.WriteLine(false ^ false);  // output: False

En el caso de los operandos de los tipos numéricos enteros, el operador ^ calcula el AND lógico bit a bit de sus operandos.

Operador lógico OR |

El operador | calcula el operador OR lógico de sus operandos. El resultado de x | y es true si x o y se evalúan como true. De lo contrario, el resultado es false.

El operador | siempre evalúa ambos operandos. Cuando el operando izquierdo se evalúa como true, el resultado de la operación es true independientemente del valor del operando derecho. Sin embargo, incluso después, se evalúa el operando derecho.

En el ejemplo siguiente, el operando derecho del operador | es una llamada de método, que se realiza independientemente del valor del operando izquierdo:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

El operador OR lógico condicional || también calcula el operador OR lógico de sus operandos, pero no evalúa el operando derecho si el izquierdo se evalúa como true.

En el caso de los operandos de los tipos numéricos enteros, el operador | calcula el OR lógico bit a bit de sus operandos.

Operador lógico condicional AND &&

El operador AND lógico condicional &&, también denominado operador AND lógico "de cortocircuito", calcula el operador AND lógico de sus operandos. El resultado de x && y es true si x y y se evalúan como true. De lo contrario, el resultado es false. Si x se evalúa como false, y no se evalúa.

En el ejemplo siguiente, el operando derecho del operador && es una llamada de método, que no se realiza si el operando izquierdo se evalúa como false:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Console.WriteLine(a);
// Output:
// False

bool b = true && SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

El operador AND lógico & también calcula el operador AND lógico de sus operandos, pero siempre evalúa ambos operandos.

Operador OR lógico condicional ||

El operador OR lógico condicional ||, también denominado operador OR lógico "de cortocircuito", calcula el operador OR lógico de sus operandos. El resultado de x || y es true si x o y se evalúan como true. De lo contrario, el resultado es false. Si x se evalúa como true, y no se evalúa.

En el ejemplo siguiente, el operando derecho del operador || es una llamada de método, que no se realiza si el operando izquierdo se evalúa como true:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Console.WriteLine(a);
// Output:
// True

bool b = false || SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

El operador OR lógico | también calcula el operador OR lógico de sus operandos, pero siempre evalúa ambos operandos.

Operadores lógicos booleanos que aceptan valores NULL

En el caso de los operandos bool?, los operadores & (AND lógico) y | (OR lógico) admiten la lógica de tres valores tal como se indica a continuación:

  • El operador & produce true solo si sus dos operandos se evalúan como true. Si x o y se evalúan como false, x & y produce false (aunque otro operando se evalúe como null). De lo contrario, el resultado de x & y es null.

  • El operador | produce false solo si sus dos operandos se evalúan como false. Si x o y se evalúan como true, x | y produce true (aunque otro operando se evalúe como null). De lo contrario, el resultado de x | y es null.

En la tabla siguiente se presenta esta semántica:

x y x e y x|y
true true true true
true false false true
true null null true
false true false true
false falso falso falso
False null False null
null true null true
null false False null
null null null null

El comportamiento de esos operadores difiere del comportamiento típico del operador con tipos de valor que aceptan valores NULL. Por lo general, un operador que se define para los operandos de un tipo de valor también se puede usar con los operandos del tipo de valor correspondiente que acepta valores NULL. Este tipo de operador genera null si alguno de sus operandos se evalúa como null. Sin embargo, los operadores & y | pueden generar un valor no NULL incluso si uno de los operandos es null. Para más información sobre el comportamiento de los operadores con tipos de valor que aceptan valores NULL, consulte la sección Operadores de elevación del artículo Tipos de valor que aceptan valores NULL.

También puede usar los operadores ! y ^ con los operandos bool?, como se muestra en el ejemplo siguiente:

bool? test = null;
Display(!test);         // output: null
Display(test ^ false);  // output: null
Display(test ^ null);   // output: null
Display(true ^ null);   // output: null

void Display(bool? b) => Console.WriteLine(b is null ? "null" : b.Value.ToString());

Los operadores lógicos condicionales && y || no admiten los operandos bool?.

Asignación compuesta

Para un operador binario op, una expresión de asignación compuesta con el formato

x op= y

es equivalente a

x = x op y

salvo que x solo se evalúa una vez.

Los operadores &, | y ^ admiten la asignación compuesta, como se muestra en el ejemplo siguiente:

bool test = true;
test &= false;
Console.WriteLine(test);  // output: False

test |= true;
Console.WriteLine(test);  // output: True

test ^= false;
Console.WriteLine(test);  // output: True

Nota

Los operadores lógicos condicionales && y || no admiten la asignación compuesta.

Prioridad de operadores

En la lista siguiente se ordenan los operadores lógicos desde la prioridad más alta a la más baja:

  • Operador de negación lógico !
  • Operador AND lógico &
  • Operador OR exclusivo lógico ^
  • Operador OR lógico |
  • Operador AND lógico condicional &&
  • Operador OR lógico condicional ||

Use los paréntesis, (), para cambiar el orden de evaluación impuesto por la prioridad de los operadores:

Console.WriteLine(true | true & false);   // output: True
Console.WriteLine((true | true) & false); // output: False

bool Operand(string name, bool value)
{
    Console.WriteLine($"Operand {name} is evaluated.");
    return value;
}

var byDefaultPrecedence = Operand("A", true) || Operand("B", true) && Operand("C", false);
Console.WriteLine(byDefaultPrecedence);
// Output:
// Operand A is evaluated.
// True

var changedOrder = (Operand("A", true) || Operand("B", true)) && Operand("C", false);
Console.WriteLine(changedOrder);
// Output:
// Operand A is evaluated.
// Operand C is evaluated.
// False

Para obtener la lista completa de los operadores de C# ordenados por nivel de prioridad, vea la sección Prioridad de operadores del artículo Operadores de C#.

Posibilidad de sobrecarga del operador

Un tipo definido por el usuario puede sobrecargar los operadores !, &, | y ^. Cuando se sobrecarga un operador binario, también se sobrecarga de forma implícita el operador de asignación compuesta correspondiente. Un tipo definido por el usuario no puede sobrecargar de forma explícita un operador de asignación compuesta.

Un tipo definido por el usuario no puede sobrecargar los operadores lógicos condicionales && y ||. Sin embargo, si un tipo definido por el usuario sobrecarga los operadores true y false y el operador & o | de cierta manera, la operación && o ||, respectivamente, se puede evaluar para los operandos de ese tipo. Para obtener más información, vea la sección Operadores lógicos condicionales definidos por el usuario de la Especificación del lenguaje C#.

Especificación del lenguaje C#

Para más información, vea las secciones siguientes de la Especificación del lenguaje C#:

Consulte también