Rust trae una amplia colección de tipos primitivos (Primitives), divididos en dos grandes grupos: tipos escalares y tipos compuestos.
(I) Tipos escalares (Scalar Types)
Representan un único valor independiente, existen 6 variedades:
- Enteros con signo :
i8,i16,i32,i64,i128,isize(tamaño adaptado al puntero del sistema) - Enteros sin signo :
u8,u16,u32,u64,u128,usize(tamaño adaptado al puntero del sistema) - Punto flotante :
f32,f64 - Carácter char : almacena valores escalares Unicode (ej:
'a','α','∞'), cada carácter ocupa 4 bytes - Booleano bool : solo dos valores posibles
true,false - Tipo unidad () : su único valor es la tupla vacía
(). Aunque tiene forma de tupla, solo guarda un valor único, por lo que no se considera tipo compuesto.
(II) Tipos compuestos (Compound Types) (se estudiarán al final)
Formados por la combinación de varios valores:
- Arreglo : ejemplo
[1, 2, 3] - Tupla : ejemplo
(1, true)
1) Formas de anotar el tipo de variable
Todas las variables pueden recibir un tipo manualmente. Los tipos numéricos soportan además los sufijos de tipo; si no hay anotación se usa un tipo por defecto:
- Entero por defecto:
i32 - Flotante por defecto:
f64
Rust también puede deducir el tipo automáticamente según el contexto del código.
2) Tipos de variable
1. Anotación explícita de tipo
Especifica directamente el tipo después del nombre de variable con : tipo, válido para todas las variables.
fn main() {
let isOpen: bool = true;
let price: f64 = 1.0;
}Lenguaje del código: JavaScript (javascript)En el ejemplo anterior, isOpen y price son variables; el fragmento : nombre_tipo después del nombre declara explícitamente el tipo de la variable.
2. Anotación por sufijo numérico
Añade un sufijo de tipo tras el valor numérico para definir su tipo, solo se usa con números.
fn main() {
let an_integer = 5i32;
}Lenguaje del código: JavaScript (javascript)Aquí no se indica el tipo con :, sino que se marca como entero de 32 bits con el sufijo i32 en el número asignado.
3. Reglas de tipo por defecto
Sin ninguna anotación ni sufijo, el compilador usa un tipo predeterminado:
- Literal entero → por defecto
i32 - Literal flotante → por defecto
f64
fn main() {
let default_float = 3.0; // automáticamente f64
let default_integer = 7; // automáticamente i32
}Lenguaje del código: JavaScript (javascript)4. Deducción contextual de tipos
El compilador puede inferir automáticamente el tipo real de la variable a partir del código posterior, sin anotación manual.
fn main() {
let mut inferred_type = 12;
inferred_type = 4294967296i64; // esta línea deduce que el tipo es i64
}Lenguaje del código: JavaScript (javascript)Variables mutables & características de las variables
1 Variable mutable
Variable modificada con la palabra clave mut, su valor se puede cambiar.
fn main() {
let mut mutable = 12;
mutable = 21; // permitido, modificación del valor
}Lenguaje del código: JavaScript (javascript)2 Tipo inmutable
Una vez definido el tipo de una variable, este no puede cambiar en toda la ejecución; asignar un valor de otro tipo causa error de compilación inmediato.
fn main() {
let mut mutable = 12;
mutable = 21; // permitido, modificación del valor
mutable = true; // error: tipo original i32, no se puede asignar un bool
}Lenguaje del código: JavaScript (javascript)C:\Users\Jack\Desktop\rustdemo>rustc hello.rs
error[E0308]: mismatched types
--> hello.rs:5:12
|
3 | let mut mutable = 12;
| -- expected due to this value
4 | mutable = 21; // permitido, modificación del valor
5 | mutable = true; // error: tipo original i32, no se puede asignar un bool
| ^^^^ expected integer, found `bool`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0308`.Lenguaje del código: JavaScript (javascript)Nota
En Rust, el valor de las variables es inmutable por defecto. Si quieres modificarlo, debes agregar la palabra clave mut; esto es distinto de otros lenguajes.
Por ejemplo, el siguiente código es común en otros lenguajes pero genera error en Rust
fn main() {
let mutable:i32 = 12;
mutable = 21; // permitido, modificación del valor
}Lenguaje del código: JavaScript (javascript)Error de compilación
C:\Users\Jack\Desktop\rustdemo>rustc hello.rs
error[E0384]: cannot assign twice to immutable variable `mutable`
--> hello.rs:4:2
|
3 | let mutable:i32 = 12;
| ------- first assignment to `mutable`
4 | mutable = 21; // permitido, modificación del valor
| ^^^^^^^^^^^^ cannot assign twice to immutable variable
|
help: consider making this binding mutable
|
3 | let mut mutable:i32 = 12;
| +++
warning: variable `mutable` is assigned to, but never used
--> hello.rs:3:6
|
3 | let mutable:i32 = 12;
| ^^^^^^^
|
= note: consider using `_mutable` instead
= note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
warning: value assigned to `mutable` is never read
--> hello.rs:4:2
|
4 | mutable = 21; // permitido, modificación del valor
| ^^^^^^^^^^^^
|
= help: maybe it is overwritten before being read?
= note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
error: aborting due to 1 previous error; 2 warnings emitted
For more information about this error, try `rustc --explain E0384`.Lenguaje del código: JavaScript (javascript)3 Sombreado de variables (Shadowing)
Volver a declarar una variable con el mismo nombre usando let sombra la variable antigua; son dos variables independientes que pueden tener tipos distintos.
fn main() {
let mutable = 12;
let mutable = true; // sombrea la variable i32 anterior, la nueva es de tipo bool
}Lenguaje del código: JavaScript (javascript)Tipos compuestos: Arreglo & Tupla
1. Arreglo
- Sintaxis:
[tipo_elemento; longitud], tipo y longitud fijos, todos los elementos deben ser del mismo tipo.
let my_array: [i32; 5] = [1, 2, 3, 4, 5];Lenguaje del código: JavaScript (javascript)2. Tupla
- Delimitada con
(), puede almacenar varios valores de tipos diferentes.
let my_tuple = (5u32, 1u8, true, -5.04f32);Lenguaje del código: JavaScript (javascript)