Learn Rust Coding · Lección

let y mutabilidad

Bindings y mutabilidad

let y mutabilidad es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 1 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.

Vincular valores con let

En Rust se crea una variable con la palabra clave let. Esto vincula un nombre a un valor.

De forma predeterminada, cada vinculación es inmutable — una vez que le asigna un valor, no puede cambiarlo.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

Inmutables de forma predeterminada

Rust hace que las variables sean inmutables deliberadamente. Esto evita cambios accidentales y facilita la comprensión del código.

Intentar reasignar una vinculación inmutable provoca un error de compilación, no un fallo en tiempo de ejecución.

let x = 5; seguido de x = 6; no se compilará.

fn main() {
    let x = 5;
    // x = 6; // this would cause a compile error
    println!("x stays {}", x);
}

Hacer mutables las variables

Cuando necesite cambiar un valor, añada la palabra clave mut. Esto marca la vinculación como mutable.

Ahora puede reasignarla tantas veces como quiera.

fn main() {
    let mut count = 0;
    count = count + 1;
    count += 1;
    println!("count is {}", count);
}

Inferencia de tipos

Rust normalmente deduce el tipo de una variable a partir de su valor. Esto se denomina inferencia de tipos.

let x = 5; asigna automáticamente a x el tipo i32.

fn main() {
    let n = 42;      // inferred as i32
    let pi = 3.14;   // inferred as f64
    println!("{} and {}", n, pi);
}

Anotaciones de tipos

También puede indicar el tipo explícitamente con dos puntos y un nombre de tipo. Esto es una anotación de tipo.

Las anotaciones son útiles cuando el compilador no puede inferir el tipo o para aportar claridad.

fn main() {
    let age: u32 = 30;
    let price: f64 = 9.99;
    println!("age {} price {}", age, price);
}

Constantes

Una const siempre es inmutable y debe tener una anotación de tipo. Su valor debe conocerse en tiempo de compilación.

Por convención, las constantes usan SCREAMING_SNAKE_CASE.

fn main() {
    const MAX_POINTS: u32 = 100_000;
    println!("Max is {}", MAX_POINTS);
}

const frente a let

Diferencias principales entre const y let:

const nunca puede ser mut.
const requiere una anotación de tipo.
const debe ser una expresión constante evaluable en tiempo de compilación.
Los valores de let pueden calcularse en tiempo de ejecución.

fn main() {
    const SECONDS_PER_HOUR: u32 = 60 * 60;
    let hours = 3;
    println!("{} seconds", SECONDS_PER_HOUR * hours);
}

Modificar valores en un bucle

Las variables mutables son habituales en los bucles, donde un valor se acumula con el tiempo.

Aquí sumamos números mediante un acumulador mut.

fn main() {
    let mut total = 0;
    for i in 1..=5 {
        total += i;
    }
    println!("Sum is {}", total);
}

Guion bajo para valores no utilizados

Si vincula un valor pero nunca lo utiliza, Rust le muestra una advertencia. Anteponer un guion bajo al nombre silencia la advertencia.

let _unused = 10; indica al compilador que esto es intencionado.

fn main() {
    let _temp = 99;
    let used = 1;
    println!("{}", used);
}

Varias vinculaciones

Puede declarar varias variables en líneas separadas, cada una con su propio let.

Cada vinculación es independiente e inmutable, a menos que se marque con mut.

fn main() {
    let name = "Rust";
    let year = 2010;
    let mut version = 1;
    version += 1;
    println!("{} born {} v{}", name, year, version);
}

Por qué ayuda la inmutabilidad

La inmutabilidad es una característica de seguridad. Cuando el compilador sabe que un valor no puede cambiar, puede ofrecer garantías más sólidas y evitar clases enteras de errores.

Opte por la mutabilidad con mut únicamente cuando realmente la necesite.

fn main() {
    let config = "production";
    // config is guaranteed not to change
    println!("Running in {}", config);
}

Comprobación rápida

¿Qué palabra clave hace que una variable de Rust pueda cambiar?

Repaso

Ha aprendido los conceptos básicos de las vinculaciones en Rust:

let vincula un nombre a un valor, inmutable de forma predeterminada.
mut hace mutable una vinculación.
Rust infiere los tipos, pero puede añadir anotaciones con :.
const se evalúa en tiempo de compilación, siempre es inmutable y necesita un tipo.

fn main() {
    let mut score: u32 = 0;
    const BONUS: u32 = 10;
    score += BONUS;
    println!("Final score: {}", score);
}

Preguntas frecuentes

¿La lección «let y mutabilidad» es gratis?

Sí — el texto completo de «let y mutabilidad» 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 «let y mutabilidad»?

Bindings y mutabilidad 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 1 de 4.

¿Cuánto tiempo toma la lección «let y mutabilidad»?

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