Operadores lógicos Parte 3

Parte de la sección Fundamentals del Journey de Rust de Coddy — lección 23 de 75.

Al comprobar múltiples condiciones, el ordenador deja de verificar tan pronto como conoce la respuesta final (esto se conoce como evaluación de cortocircuito).

Por ejemplo:

let x: i32 = 0;
let y: i32 = 5;
let result: bool = x != 0 && y / x > 2;

Aquí x es igual a 0, por lo tanto no evaluará y / x > 2. Si invirtiéramos el orden:

let result: bool = y / x > 2 && x != 0;

Esto resultará en un error porque y será dividido por 0, lo cual es ilegal en matemáticas.

Esta técnica se utiliza para optimizar la evaluación de expresiones lógicas. Por ejemplo:

let a: i32 = 0;
let b: i32 = 2;
let c: i32 = 3;
let d: i32 = 5;
let result: bool = (a > 0 && b < 2) || (c < -5 && d < 10);

En este ejemplo b < 2 y d < 10 no se evaluarán porque a > 0 y c < -5 son ambos falsos.

Desafío

Principiante

Vamos a crear un programa para decidir si es un buen día para la producción de energía con paneles solares

Inicializa estas variables:

is_sunny con el valor true
wind_speed con el valor 5.4
temperature con el valor 23
solar_panel_output con el valor 9
is_cloudy con el valor false

Crea una expresión lógica que verifique TODAS estas condiciones:

Está soleado
La velocidad del viento es menor que 10
La producción del panel solar es menor que 15
La temperatura es superior a 20 O no hay nubes

Hoja de referencia

Rust utiliza la evaluación de cortocircuito al comprobar múltiples condiciones: deja de evaluar tan pronto como se determina el resultado final.

Con && (AND), si la primera condición es falsa, la segunda no se evaluará:

let x: i32 = 0;
let y: i32 = 5;
let result: bool = x != 0 && y / x > 2; // Seguro - y/x no será evaluado

Con || (OR), si la primera condición es verdadera, la segunda no se evaluará:

let a: i32 = 0;
let b: i32 = 2;
let c: i32 = 3;
let d: i32 = 5;
let result: bool = (a > 0 && b < 2) || (c < -5 && d < 10);
// b < 2 y d < 10 no serán evaluados

Esta optimización evita cálculos innecesarios y puede prevenir errores en tiempo de ejecución como la división por cero.

Pruébalo tú mismo

fn main() {
    // Inicializar variables
    
    
    // La expresión lógica completa
    let result: bool = 
    
    // No elimines las líneas de abajo
    println!("Checking conditions for solar energy production...");
    println!("1. Is it sunny? {}", is_sunny);
    println!("2. Is wind speed safe? {}", (wind_speed < 10.0));
    println!("3. Can panels produce more? {}", (solar_panel_output < 15));
    println!("4. Is temperature good OR no clouds? {}", (temperature > 20 || !is_cloudy));
    println!("\\nFinal result - Good day for solar energy production: {}", result);
}