Variables, funciones y control de flujo

Cuatro piezas para dar instrucciones

Un programa útil necesita recordar datos, aplicar reglas, tomar decisiones y repetir trabajo. Antes de ver la sintaxis de Rust, podemos ordenar esas tareas en cuatro piezas:

01 · VariableGuardauna cantidad de energía
02 · FunciónCalculacómo transformarla
03 · CondiciónDecidesi queda energía
04 · BucleRepitela operación durante varios turnos

Rust expresa esas cuatro ideas con variables, funciones, if y bucles. No necesitas saber cómo se guarda cada valor en memoria todavía: aquí nos importa aprender a leer el recorrido del programa.

ESTADO · energyvalor inicial: 4
REGLA · let mutel cambio queda declarado
RESULTADO · variable preparadapuede actualizarse después

01 / 04LET · INMUTABLE POR DEFECTO

Una variable da nombre a un valor

let crea una variable. Rust la considera inmutable por defecto: después de let initial_energy = 4, ese nombre seguirá representando el mismo valor. Esta regla evita cambios accidentales.

Cuando el estado sí debe cambiar, se declara con mut. En el ejemplo, energy empieza con 4 y pierde una unidad. La instrucción abreviada que ves resta una unidad y guarda el nuevo resultado.

lib.rsCompila↗

/// Creates an energy reserve and consumes one unit.
#[must_use]
pub fn prepare_energy() -> i32 {
    let initial_energy = 4;
    let mut energy = initial_energy;
    energy -= 1;
    energy
}

// Playground entry point for this example.
fn main() {
    println!("available energy: {}", prepare_energy());
}

Resultado

Una función transforma una entrada

Una función reúne una regla bajo un nombre. En boost(3), el 3 llega al parámetro energy. La anotación : i32 dice que es un entero de 32 bits y -> i32 promete que la función devolverá otro entero del mismo tipo.

La última línea es una expresión: produce un valor. Como no termina en punto y coma, ese valor se devuelve. Añadir ; la convertiría en una sentencia y rompería el contrato de retorno.

lib.rsCompila↗

/// Returns twice the received energy.
#[must_use]
pub const fn boost(energy: i32) -> i32 {
    energy * 2
}

// Playground entry point for this example.
fn main() {
    println!("boosted energy: {}", boost(3));
}

Resultado

if evalúa una condición booleana

if elige una rama a partir de un valor booleano: true o false. Rust no trata números o textos como condiciones implícitas; energy > 0 debe producir explícitamente un bool.

Si la condición es verdadera se ejecuta el primer bloque. Si es falsa se ejecuta else. Como if también es una expresión, las dos ramas pueden producir el valor que devuelve la función.

lib.rsCompila↗

/// Decides whether the workshop can run another turn.
#[must_use]
pub const fn can_continue(energy: i32) -> bool {
    if energy > 0 { true } else { false }
}

// Playground entry point for this example.
fn main() {
    println!("can continue: {}", can_continue(2));
}

Resultado

for recorre cada valor de un rango

for turn in 1..=3 recorre el rango inclusivo 1, 2, 3. En cada vuelta, turn toma el siguiente valor y vuelve a ejecutarse el bloque. El programa comprueba la energía antes de restar, así que nunca baja de cero.

El rango 1..3, sin =, excluiría el final y produciría solo 1, 2. Esta diferencia es pequeña pero cambia cuántas veces se ejecuta el cuerpo.

lib.rsCompila↗

/// Runs three turns and shows how the energy changes.
pub fn run_turns(initial_energy: i32) {
    let mut energy = initial_energy;

    for turn in 1..=3 {
        if energy > 0 {
            energy -= 1;
        }

        println!("turn {turn}: {energy} remaining");
    }
}

// Playground entry point for this example.
fn main() {
    run_turns(3);
}

Resultado

.forge-journey { height: auto !important; } .forge-journey__viewport { position: static !important; height: auto !important; display: block !important; } .forge-journey__stage { min-height: auto; overflow: visible; } .forge-journey__fallback { position: static !important; width: auto !important; height: auto !important; margin: 0 !important; clip: auto !important; overflow: visible !important; } .forge-journey__fallback-chapter[hidden] { display: block !important; margin-bottom: 2rem; } .forge-journey__panel { min-height: auto !important; } .forge-journey__chapter { position: static !important; opacity: 1 !important; visibility: visible !important; transform: none !important; border-bottom: 1px solid rgba(255,255,255,.12); } .forge-journey__panel-header, .forge-journey__controls { display: none !important; }

Inferencia y anotaciones

Rust necesita conocer el tipo de cada valor, pero muchas veces puede inferirlo:

Código	Tipo que reconoce	Qué representa
`let energy = 4;`	entero, normalmente `i32`	un número sin decimales
`let temperatura = 18.5;`	decimal, normalmente `f64`	un número con decimales
`let activo = true;`	`bool`	verdadero o falso
`let simbolo = 'R';`	`char`	un carácter Unicode

Puedes escribir let energy: i32 = 4; cuando la elección de tipo importe o cuando quieras hacerla visible. No es necesario anotar cada variable.

Qué bucle elegir

Forma	Úsala cuando…	Idea clave
`for`	tienes una secuencia o un rango que recorrer	avanza automáticamente por cada elemento
`while`	debes repetir mientras una condición sea verdadera	comprueba la condición antes de cada vuelta
`loop`	quieres repetir hasta decidir salir con `break`	no tiene condición de salida implícita

En esta introducción practicarás for, la opción más directa cuando el número de pasos está descrito por un rango. El Módulo 1 profundizará en while, loop, break, continue y las etiquetas de bucle.

Antes de ejecutar: predice

Para remaining_energy(3, 2), la variable empieza en 3. El rango 0..2 produce dos vueltas: después de la primera queda 2 y después de la segunda queda 1. Para remaining_energy(2, 5), las tres vueltas finales siguen comprobando la condición, pero ya no restan porque la energía ha llegado a 0. El ejercicio trabaja con energía inicial y turnos no negativos.

Predecir el estado vuelta a vuelta es una forma sencilla de revisar un bucle antes de pedir al compilador que lo ejecute.

Objetivo

Completa remaining_energy para entradas no negativas. Cada turno consume una unidad mientras quede energía. El resultado no puede bajar de cero y cero turnos debe conservar la energía inicial.

Implementa

Sustituye `todo!` por `energy -= 1;`.

Completa el cuerpo ya estructurado: descuenta una unidad cuando la condición permite entrar.

/// Calculates the energy remaining after several turns.
pub fn remaining_energy(initial_energy: i32, turns: i32) -> i32 {
    let mut energy = initial_energy;
    for _turn in 0..turns {
        if energy > 0 {
            todo!("subtract one unit of energy");
        }
    }
    energy
}

Comprueba

Ejecuta tres casos visibles y usa el diagnóstico para corregir el código.

Pruebas visibles

descuenta, se detiene en cero y admite cero turnos

Compilador—

Modifica el código antes de ejecutar las pruebas.

Ayuda

Consulta pistas progresivas o compara con la solución.

Solución comentadaSolución↗

/// Calculates the remaining energy without allowing a non-negative input to drop below zero.
#[must_use]
pub fn remaining_energy(initial_energy: i32, turns: i32) -> i32 {
    let mut energy = initial_energy;

    for _turn in 0..turns {
        if energy > 0 {
            energy -= 1;
        }
    }

    energy
}

// Playground entry point for this example.
fn main() {
    println!("{}", remaining_energy(3, 2));
    println!("{}", remaining_energy(2, 5));
    println!("{}", remaining_energy(4, 0));
}

Resultado

Resumen

let crea variables inmutables por defecto; let mut permite cambios explícitos.
Rust puede inferir tipos básicos, aunque una anotación como : i32 permite fijarlos.
Una función declara tipos para sus parámetros y retorno; su expresión final devuelve el valor.
if exige una condición booleana y ejecuta exactamente una de sus ramas.
for recorre secuencias y rangos; .. excluye el final y ..= lo incluye.
while repite según una condición y loop continúa hasta un break; se estudiarán en profundidad más adelante.

Fuentes

The Rust Programming Languagech03-01–ch03-05 · Klabnik, Nichols, Krycho y la comunidad de Rust
Rust by Examplevariable_bindings/functions/flow_control
Comprehensive Rustbasic-syntax/control-flow-basics · Geisler y colaboradores (Google)

Variables, funciones y control de flujo

Cuatro piezas para dar instrucciones

Inferencia y anotaciones

Qué bucle elegir

Antes de ejecutar: predice

Haz que la energía dure todos los turnos posibles.

Implementa

Calcular la energía restante

Comprueba

Ayuda

Resumen

Fuentes