Variables y tipos de datos en Rust

Las variables y tipos de datos en Rust son fundamentales para desarrollar aplicaciones seguras y eficientes. Además, este lenguaje, conocido por su enfoque en la seguridad y el rendimiento, ofrece un sistema de tipos estático que permite detectar errores en tiempo de compilación, lo cual asegura un código más robusto. Por esta razón, en este artículo exploraremos cómo funcionan las variables y tipos de datos en Rust, y aprenderás a utilizarlos correctamente en tus proyectos. Así que, sin más preámbulos, manos a la obra.

¿Qué son las variables en Rust y cómo funcionan?

En Rust, las variables se utilizan para almacenar valores que pueden ser inmutables o mutables. Por defecto, todas las variables son inmutables, lo que significa que no pueden cambiar de valor una vez que se les ha asignado. Este comportamiento predeterminado fomenta la seguridad, ya que evita errores relacionados con estados inesperados en el programa.

Declaración de variables inmutables

Para declarar una variable, se utiliza la palabra clave let. Por ejemplo:

fn main() {
    let x = 10; // Variable inmutable
    println!("El valor de x es: {}", x);
}

Intentar modificar una variable inmutable generará un error de compilación:

x = 15; // Error: no se puede reasignar a una variable inmutable

Variables mutables

Si necesitas que una variable cambie su valor, debes declararla como mutable usando la palabra reservada mut:

fn main() {
    let mut y = 20;
    println!("Valor inicial de y: {}", y);
    y = 25; // Modificando el valor
    println!("Nuevo valor de y: {}", y);
}

El uso de variables mutables debe ser intencional y controlado para mantener la integridad del programa.

Tipos de datos en Rust

El sistema de tipos de Rust es uno de sus puntos fuertes. Los tipos de datos en Rust se dividen en dos categorías principales: tipos escalares y tipos compuestos.

Tipos escalares

Los tipos escalares representan valores únicos y son fundamentales para trabajar con datos básicos.

1. Enteros
   • Rust ofrece enteros con y sin signo(i8, u8, i16, u16, etc.)
   • Los enteros con signo(i) pueden contener números negativos y positivos, mientras que los sin signo(u) solo contienen positivos.

     fn main() {
         let num: i32 = -42;
         let positivo: u32 = 42;
         println!("Entero: {}, Positivo: {}", num, positivo);
     }
     

2. Flotantes
   • Representan números y se declaran como f32 o f64.

     fn main() {
         let pi: f64 = 3.14159;
         println!("El valor de pi es: {}", pi);
     }
     

3. Booleanos
   • Los valores booleanos (bool) son true o false.

     fn main() {
         let activo: bool = true;
         println!("El estado es activo: {}", activo);
     }
     

4. Caracteres
   • Los caracteres (char) representan un único carácter Unicode.

     fn main() {
         let letra = 'R';
         let emoji = '😊';
         println!("Letra: {}, Emoji: {}", letra, emoji);
     }
     

Tipos compuestos

Los tipos compuestos en Rust permiten agrupar valores.

1. Tuplas
   • Una tupla puede contener valores de diferentes tipos.

     fn main() {
         let tupla: (i32, f64, char) = (42, 3.14, 'R');
         println!("Tupla completa: {:?}", tupla);
     }
     

     Para acceder a los elementos de una tupla, se utilizan índices:

     fn main() {
         let tupla = (1, "Hola", 3.5);
         println!("El segundo elemento es: {}", tupla.1);
     }
     

2. Arrays
   • Los arrays contienen elementos del mismo tipo con un tamaño fijo

     fn main() {
         let numeros = [1, 2, 3, 4, 5];
         println!("Primer número: {}", numeros[0]);
     }
     

     Intentar acceder a un índice fuera de rango generará un error en tiempo de ejecución

Sombras de variables en Rust

La «sombra» de variables (variable shadowing) en un concepto en el que puedes declarar una nueva variable con el mismo nombre que una existente, reemplazándola (sombrea) en el contexto actual. Esto es útil para transformar valores sin hacerlos mutables.

fn main() {
    let x = 5;
    let x = x + 1; // Nueva variable con el mismo nombre
    println!("El valor de x es: {}", x);
}

En este caso, x tiene un nuevo valor y el anterior queda fuera del alcance.

Inferencia de tipos

Rust tiene un sistema de inferencia de tipos poderoso. Aunque puedes declarar explícitamente el tipo de una variable, el compilador puede deducirlo basado en el valor asignado:

fn main() {
    let numero = 10; // Inferido como i32
    let decimal = 4.5; // Inferido como f64
    println!("Número: {}, Decimal: {}", numero, decimal);
}

Conclusión

En conclusión las variables y tipos de datos en Rust son el pilar para construir aplicaciones robustas y seguras. Comprender cómo declarar variables, aprovechar la mutabilidad y trabajar con los diferentes tipos de datos te permitirá escribir código más eficiente y confiable.

Rust no solo ofrece seguridad en memoria, sino también un sistema de tipos que te ayuda a evitar errores comunes en tiempo de compilación. Ahora que tienes una compresión clara de las variables y tipos de datos en Rust, estás listo para avanzar al siguiente paso: el control de flujo y las estructuras de bucle que podrás encontrar en los siguientes artículos. ¡Explorar el mundo de Rust llevará tus habilidades de programación al siguiente nivel!

Fuente: Documentación oficial de Rust.
Te puede interesar: Rust el lenguaje de programación del futuro.