Tipos de datos en Rust

Todo valor en Rust tiene un tipo: una etiqueta que le dice al compilador qué clase de dato es (un número entero, un decimal, texto, verdadero/falso, etc.). Conocer el tipo le permite a Rust revisar tu código en busca de errores antes de que se ejecute.

Como viste con las variables, Rust normalmente puede deducir el tipo por ti. Aun así, viene bien conocer los tipos principales por su nombre, porque los verás en mensajes de error y en las firmas de las funciones.

Enteros (números sin decimales)

Los enteros son números sin punto decimal, como 42 o -7. Rust tiene varios tipos de enteros que se diferencian por su tamaño y por si admiten números negativos:

Tipo	¿Con signo?	Uso habitual
i32	Sí (puede ser negativo)	El tipo por defecto: úsalo salvo que tengas un motivo para no hacerlo
u32	No (de 0 hacia arriba)	Conteos, tamaños, cosas que no pueden ser negativas
i64 / u64	Sí / No	Números muy grandes
usize	No	Índices para acceder a colecciones

fn main() {
    let temperature = -5;      // i32 por defecto
    let count: u32 = 100;      // sin signo, indicado explícitamente
    println!("{temperature} grados, el contador vale {count}");
}

Salida:

-5 grados, el contador vale 100

▶ Pruébalo tú mismo

Nota

“Con signo” (signed) significa que el número puede ser negativo; “sin signo” (unsigned, los tipos que empiezan por u) significa que solo puede ser cero o positivo. Si tienes dudas, i32 es una opción segura.

Números de coma flotante (decimales)

Para números con decimales se usan los tipos de coma flotante. Hay dos: f64 (el de por defecto, de doble precisión) y f32.

fn main() {
    let pi = 3.14159;      // f64 por defecto
    let price: f32 = 9.99;
    println!("Pi vale {pi}, el precio es {price}");
}

Salida:

Pi vale 3.14159, el precio es 9.99

▶ Pruébalo tú mismo

Quédate con f64 a menos que necesites específicamente el f32, que es más pequeño. f64 es más preciso e igual de rápido en el hardware actual.

Booleanos

Un booleano (bool) es el tipo más sencillo: solo puede ser true (verdadero) o false (falso). Los usarás todo el tiempo en sentencias if y en condiciones.

fn main() {
    let is_logged_in = true;
    let has_permission: bool = false;
    println!("sesión iniciada: {is_logged_in}, permiso: {has_permission}");
}

Salida:

sesión iniciada: true, permiso: false

▶ Pruébalo tú mismo

Caracteres

Un char guarda un solo carácter y se escribe entre comillas simples ' '. Un char de Rust puede ser cualquier valor escalar Unicode, lo que incluye la mayoría de los emojis. Eso sí, algunos más complejos (como las banderas o los emojis formados por varios caracteres unidos) no caben en uno solo.

fn main() {
    let letter = 'R';
    let symbol = '$';
    let crab = '🦀';
    println!("{letter} {symbol} {crab}");
}

Salida:

R $ 🦀

▶ Pruébalo tú mismo

Precaución

Las comillas simples ('R') son para un solo char. Las comillas dobles ("R") son para texto (cadenas). Confundirlas es un error muy común al principio.

Cadenas de texto

En Rust, el texto se escribe entre comillas dobles. Te vas a encontrar con dos tipos de cadena:

• &str: un slice de cadena (una “porción” de texto). Normalmente es texto que escribes directamente en tu código (un “literal de cadena”).
• String: un texto propio que puede crecer, y que puedes modificar e ir construyendo.

fn main() {
    let greeting = "¡Hola";              // &str
    let mut name = String::from("Ferris"); // String
    name.push_str(" el cangrejo");       // los String pueden crecer
    println!("{greeting}, {name}!");
}

Salida:

¡Hola, Ferris el cangrejo!

▶ Pruébalo tú mismo

No te preocupes todavía por la diferencia entre &str y String. Tiene que ver con el ownership (propiedad), que aprenderás muy pronto. Por ahora, basta con esto: usa "..." para el texto y recurre a String cuando necesites construirlo o modificarlo.

Anotaciones de tipo

Casi siempre Rust deduce el tipo. Pero a veces necesita una pista, por ejemplo cuando conviertes texto en un número (lo verás en la página de Conversión de tipos). El tipo se añade con dos puntos:

let x: i32 = 42;
let y: f64 = 3.5;
let active: bool = true;

Referencia rápida

Tipo	Qué guarda	Ejemplo
i32	Número entero (por defecto)	let n = 42;
u32	Número entero no negativo	let n: u32 = 42;
f64	Número decimal (por defecto)	let pi = 3.14;
bool	true o false	let ok = true;
char	Un carácter	let c = 'A';
&str	Texto literal	let s = "hi";
String	Texto que puede crecer	let s = String::from("hi");

Práctica

1. El perfil de un jugador

Describe a un personaje de videojuego con una variable de cada tipo: un nombre (&str), un nivel (i32), un porcentaje de salud (f64), un indicador is_online (bool) y una letra de rango (char). Imprímelos todos en una línea. Pista: un char usa comillas simples y el texto, comillas dobles.

Ver solución

fn main() {
    let name = "Ferris";   // &str
    let level = 7;         // i32
    let health = 82.5;     // f64
    let is_online = true;  // bool
    let rank = 'A';        // char

    println!("{name} | nivel {level} | {health}% | en línea: {is_online} | rango {rank}");
}

Salida:

Ferris | nivel 7 | 82.5% | en línea: true | rango A

▶ Pruébalo tú mismo

2. Construye una frase

Empieza con String::from("Rust"), añádele " es rápido" y " y seguro", e imprime el resultado. Pista: el String tiene que declararse con mut para que push_str pueda cambiarlo.

Ver solución

fn main() {
    let mut sentence = String::from("Rust");
    sentence.push_str(" es rápido");
    sentence.push_str(" y seguro");
    println!("{sentence}");
}

Salida:

Rust es rápido y seguro

▶ Pruébalo tú mismo

Resumen

• Todo valor tiene un tipo; normalmente Rust lo deduce.
• Números enteros → i32 (por defecto). Decimales → f64 (por defecto).
• bool es true/false; char es un solo carácter entre comillas simples.
• El texto va entre comillas dobles: &str para los literales, String para el texto que puede crecer.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. ¿Cuál es el tipo de entero por defecto en Rust si no indicas ninguno?

u32 i32 i64

2. ¿Cómo distingue Rust un literal char de un literal de cadena?

No hay diferencia: los dos se escriben igual Los literales char usan comillas simples y los de cadena, comillas dobles Los literales char usan comillas dobles y los de cadena, comillas simples

3. ¿Qué tipo es un texto propio que puede crecer y que puedes modificar?

&str String char

4. ¿Cuál es el tipo de coma flotante por defecto en Rust?

f32 f64 f128

5. ¿Qué tipo deduciría Rust para let greeting = "Hola";?

String &str char

Puntuación: 0 / 5

Para leer más

• Data Types: The Rust Book (en inglés): todos los tipos escalares con su tamaño y rango, además del desbordamiento de enteros (overflow) y los tipos compuestos (tuplas y arrays).
• Primitives: Rust by Example (en inglés): ejemplos ejecutables de cada tipo básico, con una continuación sobre literales como 1_000 y 0x80.
• i32: documentación de la biblioteca estándar (en inglés): los valores más pequeño y más grande (i32::MIN, i32::MAX) y los muchos métodos que tienen los números.
• char: documentación de la biblioteca estándar (en inglés): qué es un valor escalar Unicode y por qué un char siempre ocupa 4 bytes.
• String: documentación de la biblioteca estándar (en inglés): cómo se relaciona String con &str, y todos los métodos para construir y modificar texto.