Primeros pasos en Rust - Tipos de Datos

Apuntes de Rust - Parte 3

Constantes

Rust da prioridad a que las variables sean inmutables porque fomenta la escritura de código seguro y libre de errores. Al hacer que las variables sean inmutables por defecto, Rust evita muchos problemas comunes en la programación, como cambios accidentales o inesperados en los valores de las variables.

El compilador de Rust garantiza que cuando se decide que un variable no cambiará, realmente no cambiará, por lo que no tienes que hacer un seguimiento de ello. El código, por lo tanto, es más fácil de comprender. Además, la inmutabilidad es fundamental para garantizar la seguridad y facilidad de concurrencia en Rust. Al prevenir cambios concurrentes en los datos compartidos, se evitan problemas como las condiciones de carrera y las violaciones de seguridad.

La mutabilidad puede ser muy útil y puede hacer que el código sea más conveniente de escribir. Aunque las variables son inmutables por defecto, recordemos que se pueden hacer mutables agregando la palabra reservada mut delante del nombre de la variable.

Las constantes, al igual que las variables son inmutables, las constantes son valores que se asocian a un nombre y no se les permite cambiar durante la ejecución, pero existen algunas diferencias entre las constantes y las variables.

No se puede usar mut con constantes. Las constantes no solo son inmutables por defecto, sino que siempre son inmutables. Declara constantes utilizando la palabra clave const en lugar de let, y el tipo del valor debe ser anotado.

const MINUTOS_HORA: u32 = 60;

Las constantes solo pueden ser asignadas a una expresión constante, no al resultado de un valor que solo se podría calcular en tiempo de ejecución.

const MINUTOS_DIA: u32 = 60*24;

Las constantes son válidas durante todo el tiempo de ejecución de un programa, dentro del ámbito en el que se declararon.


Tipos de Datos

Cada valor en Rust es de un cierto tipo de dato, lo que le indica a Rust qué tipo de datos se está especificando para que sepa cómo trabajar con esos datos. El compilador generalmente puede inferir qué tipo queremos usar en función del valor y cómo lo usamos.

Aquí tienes una tabla con los tipos de datos escalares en Rust, incluyendo los tipos con signo y sin signo, sus tamaños en bytes y un ejemplo de cada uno:

Tipo de DatoTamaño en BytesRango de ValoresCon Signo / Sin SignoEjemplo
i81-128 a 127Con signolet x: i8 = -10;
u810 a 255Sin signolet y: u8 = 42;
i162-32,768 a 32,767Con signolet a: i16 = -200;
u1620 a 65,535Sin signolet b: u16 = 1000;
i324-2,147,483,648 a 2,147,483,647Con signolet c: i32 = -50000;
u3240 a 4,294,967,295Sin signolet d: u32 = 200000;
i648-9,223,372,036,854,775,808 a 9,223,372,036,854,775,807Con signolet e: i64 = -1000000000;
u6480 a 18,446,744,073,709,551,615Sin signolet f: u64 = 9000000000;
i12816...Con signolet g: i128 = -12345678901234567890;
u12816...Sin signolet h: u128 = 12345678901234567890;
isizedepende de la arquitectura...Con signolet size: isize = 42;
usizedepende de la arquitectura...Sin signolet index: usize = 10;
f324números de punto flotante-let pi: f32 = 3.14;
f648números de punto flotante-let e: f64 = 2.71828;
bool1true o false-let is_rust_fun: bool = true;
char4un carácter Unicode-let c: char = 'A';

Podemos resumir estos tipos de la siguiente forma:

bool, char, str                 // boolean, character, string
i8, i16, i32, i64, i128         // integer (signed)
u8, u16, u32, u64, u128         // integer (unsigned)
f32, f64                        // float

Los escalares se pueden expresar en diferentes bases numéricas.

Base NuméricaDeclaración de Variable
Decimallet decimal = 42;
Hexadecimallet hexadecimal = 0x2A;
Octallet octal = 0o52;
Binariolet binario = 0b101010;
Bytelet byte = b'A';

Tipos Compuestos

Los tipos compuestos pueden agrupar múltiples valores en un solo tipo. Rust tiene dos tipos compuestos primitivos: tuplas y arreglos.

En Rust, una tupla es una colección ordenada de elementos de diferentes tipos. Se define utilizando paréntesis y separando los elementos con comas. Cada elemento de la tupla puede tener un tipo diferente. Ejemplo:

let una_tupla = (42, "Hola", 3.14);

En este ejemplo, una_tupla es una tupla que contiene un entero, una cadena de texto y un número de punto flotante.

Para acceder a los elementos de una tupla usamos el operador punto y la posición del elemento.

let una_tupla = (42, "Hola", 3.14);
println!("Valor en la posición 0 de la tupla: {}", una_tupla.0);
println!("Valor en la posición 1 de la tupla: {}", una_tupla.1);
println!("Valor en la posición 2 de la tupla: {}", una_tupla.2);

Un arreglo es una colección de elementos del mismo tipo con una longitud fija. Se define utilizando corchetes y especificando el tipo de los elementos y el número de elementos que contendrá el arreglo. Ejemplo:

let un_arreglo = [1, 2, 3, 4, 5];

En este ejemplo, un_arreglo es un arreglo que contiene cinco enteros.

Es importante tener en cuenta que las tuplas y los arreglos en Rust tienen una longitud fija y no pueden crecer ni reducir su tamaño una vez que se han definido.

Para acceder a los elementos de una tupla usamos el operador punto y la posición del elemento.

let un_arreglo = [1, 2, 3, 4, 5];
println!("Valor en la posición 0 del arreglo: {}", un_arreglo[0]);
println!("Valor en la posición 1 del arreglo: {}", un_arreglo[1]);
println!("Valor en la posición 2 del arreglo: {}", un_arreglo[2]);

Nota: Los índices cumplen las mismas reglas que en la mayoría de los lenguajes de programación, inician en la posición 0 y vamos hasta la posición longitud del arreglo - 1.

Otro ejemplo, un arreglo de cadenas de texto:

fn main() {
    let dias_semana = ["Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo"];

    println!("día 1: {}", dias_semana[0]);
    println!("día 2: {}", dias_semana[1]);
    println!("día 3: {}", dias_semana[2]);
    println!("día 4: {}", dias_semana[3]);
    println!("día 5: {}", dias_semana[4]);
    println!("día 6: {}", dias_semana[5]);
    println!("día 7: {}", dias_semana[6]);
}

Referencias

  • The Rust Programming Language. 2nd Edition by Steve Klabnik and Carol Nichols, with contributions from the Rust Community. 2023

Did you find this article valuable?

Support Jesse Padilla by becoming a sponsor. Any amount is appreciated!