Learn Rust Coding · Lección

Expresiones y sentencias

La última expresión

Expresiones y sentencias es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

Sentencias frente a expresiones

Rust distingue dos tipos de código:

Las sentencias realizan una acción y no devuelven ningún valor.
Las expresiones se evalúan y producen un valor.

Esta distinción determina cómo devuelven valores las funciones.

fn main() {
    let x = 5;      // a let statement
    let y = x + 1;  // x + 1 is an expression
    println!("{}", y);
}

let es una sentencia

Un enlace let es una sentencia. No devuelve ningún valor, por lo que no puede escribir let a = (let b = 6);.

fn main() {
    let a = 6;
    // let c = (let d = 6); // error: let is not an expression
    println!("{}", a);
}

Las expresiones se evalúan y producen valores

Las operaciones aritméticas, las llamadas a funciones y los literales son expresiones porque producen un valor.

5
2 + 3
square(4)

fn main() {
    let v = 2 + 3 * 4;
    println!("{}", v);
}

Los bloques son expresiones

Un bloque { ... } es una expresión en sí mismo. Su valor es el de la última expresión que contiene, siempre que esta no tenga un punto y coma al final.

fn main() {
    let y = {
        let x = 3;
        x + 1
    };
    println!("y is {}", y);
}

El punto y coma importa

Agregar un punto y coma convierte una expresión en una sentencia y descarta su valor.

x + 1 — expresión que produce un valor.
x + 1; — sentencia que produce ().

fn main() {
    let y = {
        let x = 3;
        x + 1   // no semicolon: this is the block's value
    };
    println!("{}", y);
}

La última expresión se devuelve

En una función, la expresión final sin punto y coma se convierte en el valor de retorno. Este es el estilo idiomático de Rust.

fn main() {
    println!("{}", five());
}

fn five() -> i32 {
    5
}

El punto y coma interrumpe los retornos

Si agrega accidentalmente un punto y coma a la última línea, la función devuelve () en lugar de su valor; es un error común entre principiantes.

fn main() {
    println!("{}", plus_one(10));
}

fn plus_one(n: i32) -> i32 {
    n + 1   // correct: no semicolon
}

if como expresión

Como if es una expresión, puede asignar su resultado a una variable. Ambas ramas deben producir el mismo tipo.

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("number is {}", number);
}

loop como expresión

Un loop puede devolver un valor mediante break. El valor que aparece después de break se convierte en el resultado del bucle.

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("result {}", result);
}

match como expresión

Un match también es una expresión. Cada rama produce un valor, y el valor de la rama coincidente es el resultado.

fn main() {
    let n = 2;
    let label = match n {
        1 => "one",
        2 => "two",
        _ => "many",
    };
    println!("{}", label);
}

Unirlo todo

Tratar los bloques y el flujo de control como expresiones hace que Rust sea conciso: puede calcular y devolver un resultado en un único paso fluido.

fn main() {
    let score = 85;
    let grade = if score >= 90 { 'A' } else if score >= 80 { 'B' } else { 'C' };
    println!("grade {}", grade);
}

Comprobación rápida

¿Qué efecto tiene agregar un punto y coma a una expresión?

Resumen

Expresiones y sentencias en Rust:

Las sentencias, como let, realizan una tarea, pero no devuelven ningún valor.
Las expresiones se evalúan y producen un valor.
Los bloques, if, match y loop son expresiones.
La última expresión sin punto y coma es el valor de retorno.

fn main() {
    let x = { let a = 2; a * a };
    let y = if x > 3 { "big" } else { "small" };
    println!("{} {}", x, y);
}

Preguntas frecuentes

¿La lección «Expresiones y sentencias» es gratis?

Sí — el texto completo de «Expresiones y sentencias» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Expresiones y sentencias»?

La última expresión Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Expresiones y sentencias»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding