1. Y (conjunción)
* símbolo: `&&` (C ++, Java, JavaScript, Php, C#, Go, Rust), `y` (Python, Ruby),` &`(Pascal, VBA)
* Propósito: Devuelve `true` if ambos Los operandos son 'verdaderos'. De lo contrario, devuelve `falso`.
* Tabla de verdad:
| Operando 1 | Operando 2 | Resultado |
| ---------- | ---------- | -------- |
| `True` | `True` | `True` |
| `True` | `falso` | `falso` |
| `falso` | `True` | `falso` |
| `falso` | `falso` | `falso` |
* Ejemplo (JavaScript):
`` `JavaScript
dejar edad =25;
Dejar huicense =verdadero;
if (edad> =16 &&hasicense) {
console.log ("puede conducir legalmente");
} demás {
console.log ("no puede conducir legalmente");
}
`` `` ``
En este caso, la condición `edad> =16 &&Haslicense` solo será` verdadera 'si la persona tiene al menos 16 * y * tiene una licencia.
2. O (disyunción)
* símbolo: `||` (C ++, Java, JavaScript, Php, C#, Go, Rust), `Or` (Python, Ruby),` | `(Pascal, VBA)
* Propósito: Devuelve `True` if al menos uno de los operandos es 'verdadero'. Devuelve `falso 'solo si ambos operandos son` falsos'.
* Tabla de verdad:
| Operando 1 | Operando 2 | Resultado |
| ---------- | ---------- | -------- |
| `True` | `True` | `True` |
| `True` | `falso` | `True` |
| `falso` | `True` | `True` |
| `falso` | `falso` | `falso` |
* Ejemplo (Python):
`` `Python
temperatura =20
israining =falso
Si la temperatura <0 o Israining:
Imprimir ("Quédate adentro")
demás:
Imprimir ("Disfruta del clima")
`` `` ``
El mensaje "permanecer adentro" se imprimirá si la temperatura está por debajo de 0 * o * está lloviendo (o ambos).
3. No (negación)
* símbolo: `!` (C ++, Java, JavaScript, Php, C#, Go, Rust), `no` (Python, Ruby),` no` (Pascal), `no` (VBA)
* Propósito: Invierte el valor booleano del operando. Si el operando es `verdadero`,` no 'lo hace `falso' y viceversa.
* Tabla de verdad:
| Operando | Resultado |
| ---------- | -------- |
| `True` | `falso` |
| `falso` | `True` |
* Ejemplo (C ++):
`` `C ++
bool isloggedin =false;
if (! isloggedin) {
cout <<"Por favor, inicie sesión" <
cout <<"bienvenido" <
`` `` ``
El código verifica si el usuario * no * inició sesión (`! IsloggedIn`).
4. Xor (exclusivo o)
* símbolo: `^` (C ++, Java, JavaScript, Php, C#, Go, Rust), `Xor` (Pascal),` Xor` (VBA). Python requiere usar `! =` Para emular Xor para booleanos.
* Propósito: Devuelve `true` if exactamente uno de los operandos es 'verdadero'. Devuelve `falso` si ambos operandos son` verdaderos 'o ambos operandos son `falsos'. En otras palabras, los operandos deben ser diferentes.
* Tabla de verdad:
| Operando 1 | Operando 2 | Resultado |
| ---------- | ---------- | -------- |
| `True` | `True` | `falso` |
| `True` | `falso` | `True` |
| `falso` | `True` | `True` |
| `falso` | `falso` | `falso` |
* Ejemplo (PHP):
`` `PHP
$ isadult =true;
$ hasstudentDiscount =false;
if ($ isadult ^ $ hasstudentdiscount) {
echo "elegible para un descuento parcial";
} demás {
Echo "No es elegible para un descuento parcial";
}
`` `` ``
Este ejemplo ilustra un escenario en el que ser un adulto *o *tener un descuento de estudiante califica para un descuento *parcial *, pero no *ambos *.
5. Cortocircuito
Muchos lenguajes de programación implementan una evaluación de "cortocircuito" para operadores `y` y` o`. Esta optimización puede mejorar el rendimiento y evitar errores:
* `y` (` &&`o` y`): Si el primer operando es `falso ', toda la expresión es` falsa', por lo que el segundo operando es * no * evaluado.
* `o` (` || `o` or`): Si el primer operando es `verdadero ', toda la expresión es` verdadera', por lo que el segundo operando es * no * evaluado.
Ejemplo de cortocircuito (JavaScript):
`` `JavaScript
Sea x =5;
Let isValid =false;
if (isValid &&x ++> 0) {// x ++ solo se evalúa si isValid es verdadero
console.log ("condición MET");
}
console.log (x); // Salida:5 (x no se incrementó)
`` `` ``
En este caso, dado que `isValid` es` falso`, `x ++> 0` nunca se evalúa, por lo que` x` permanece 5. Esto es importante si el segundo operando tiene efectos secundarios (como incrementar una variable) o si evaluarlo podría conducir a un error (por ejemplo, dividir por cero).
Consideraciones importantes:
* Precedencia del operador: Los operadores lógicos tienen una precedencia específica en relación con otros operadores (aritmética, comparación, etc.). Use paréntesis `()` para garantizar que las expresiones se evalúen en el orden que pretende.
* Tipos de datos: Los operadores lógicos generalmente operan con valores booleanos (verdadero o falso). Muchos idiomas convertirán automáticamente otros tipos de datos a valores booleanos basados en ciertas reglas (por ejemplo, 0 es falso, no cero es verdadero; la cadena vacía es falsa, la cadena no vacía es verdadera). Tenga en cuenta cómo su idioma maneja estas conversiones.
* Operadores bitwise versus operadores lógicos: Algunos idiomas tienen operadores bit a bit (por ejemplo, `&`, `|`, `^`, `~` en c/c ++/java) que se parecen a los operadores lógicos. Los operadores de bit a bit realizan operaciones en bits individuales de valores enteros, mientras que los operadores lógicos trabajan en valores booleanos y devuelven los resultados booleanos. ¡No los confundas!
Al comprender y usar efectivamente operadores lógicos, puede crear programas complejos y robustos que respondan de manera inteligente a diferentes condiciones.