Tipos de datos en Rust
Los tipos de datos básicos en el lenguaje Rust son los siguientes.
Enteros (Integer)
El tipo entero, abreviado como entero, se divide en las siguientes categorías según la longitud de bits y si tiene signo:
| Longitud de bits | Con signo | Sin signo |
|---|---|---|
| 8-bit | i8 | u8 |
| 16-bit | i16 | u16 |
| 32-bit | i32 | u32 |
| 64-bit | i64 | u64 |
| 128-bit | i128 | u128 |
| arch | isize | usize |
Los dos tipos de enteros isize y usize se utilizan para medir el tamaño de los datos; su longitud de bits depende de la plataforma objetivo en la que se ejecutan. Si es un procesador de arquitectura de 32 bits, se utilizará un entero de 32 bits.
Las formas de expresar enteros son las siguientes:
| Base | Ejemplo |
|---|---|
| Decimal | 98_222 |
| Hexadecimal | 0xff |
| Octal | 0o77 |
| Binario | 0b1111_0000 |
| Byte (solo puede representar el tipo u8) | b'A' |
Es evidente que algunos enteros contienen un guion bajo en el medio; este diseño permite que las personas puedan juzgar más fácilmente el valor aproximado de un número grande al ingresarlo.
Punto flotante (Floating-Point)
Rust, al igual que otros lenguajes, admite números de punto flotante de 32 bits (f32) y de 64 bits (f64). De forma predeterminada, 64.0 representará un número de punto flotante de 64 bits, porque los procesadores de las computadoras modernas calculan casi a la misma velocidad ambos tipos de números de punto flotante, pero el de 64 bits tiene mayor precisión.
Ejemplo
let x = 2.0; // f64
let y: f32 = 3.0; // f32
}
Operaciones matemáticas
Usa un programa para reflejar las operaciones matemáticas:
Ejemplo
let sum = 5 + 10; // Suma
let difference = 95.5 - 4.3; // Resta
let product = 4 * 30; // Multiplicación
let quotient = 56.7 / 32.2; // División
let remainder = 43 % 5; // Módulo (resto)
}
Muchos operadores, al agregar el signo = después, significan auto-operación, por ejemplo:
sum += 1Equivale asum = sum + 1。
Nota:Rust no admite++y--, porque la aparición de estos dos operadores antes o después de la variable afecta la legibilidad del código y reduce la capacidad de los desarrolladores para ser conscientes del cambio de la variable.
Booleano
El tipo booleano se representa con bool, y su valor solo puede ser true o false.
Carácter
El tipo carácter se representa con char.
El tipo char de Rust tiene un tamaño de 4 bytes y representa valores escalares Unicode, lo que significa que puede admitir caracteres no ingleses como chino, japonés y coreano; incluso los emojis y los espacios de ancho cero son valores char válidos en Rust.
El rango de valores Unicode va desde U+0000 hasta U+D7FF y desde U+E000 hasta U+10FFFF (incluidos ambos extremos). Sin embargo, el concepto de "carácter" no existe en Unicode, por lo que su intuición sobre qué es un "carácter" puede no coincidir con el concepto de carácter en Rust. Por lo tanto, generalmente se recomienda usar cadenas para almacenar texto UTF-8 (los caracteres no ingleses deben aparecer en las cadenas siempre que sea posible).
Nota:Dado que la codificación de los caracteres chinos tiene dos tipos (GBK y UTF-8), el uso de cadenas chinas en la programación puede provocar caracteres ilegibles, porque la codificación del programa fuente no coincide con la del terminal. Por lo tanto, en Rust tanto las cadenas como los caracteres deben usar codificación UTF-8; de lo contrario, el compilador mostrará un error.
Tipos compuestos
Una tupla es un conjunto de datos encerrado entre un par de( )paréntesis, y puede contener diferentes tipos de datos:
Ejemplo
// tup.0 es igual a 500
// tup.1 es igual a 6.4
// tup.2 es igual a 1
let (x, y, z) = tup;
// y es igual a 6.4
Los arreglos se delimitan con un par de[ ]corchetes que incluyen datos del mismo tipo.
Ejemplo
// a es un arreglo de enteros de longitud 5
let b = ["January", "February", "March"];
// b es un arreglo de cadenas de longitud 3
let c: [i32; 5] = [1, 2, 3, 4, 5];
// c es un arreglo de i32 de longitud 5
let d = [3; 5];
// Equivale a let d = [3, 3, 3, 3, 3];
let first = a[0];
let second = a[1];
// Acceso al arreglo
a[0] = 123; // Error: el arreglo a es inmutable
let mut a = [1, 2, 3];
a[0] = 4; // Correcto