En el último artículo sobre el lenguaje de programación Rust, analizamos variables, constantes y sombras.
Cubrir tipos de datos es natural ahora.
Tabla de Contenidos
¿Qué son los tipos de datos?
Cambie el orden de estas palabras y tendrá su respuesta: «Tipo de datos» -> «Tipo de datos».
La computadora almacena datos como arena
1
Pero para entenderlo mientras leemos, usamos tipos de datos para ilustrar esos arena
1
Muy malo.
Rust tiene dos tipos de tipos de datos:
- tipo de datos escalares: Un tipo que solo almacena un único valor.
- tipo de datos compuesto: Un tipo que almacena múltiples valores, incluso valores de diferentes tipos.
En este artículo, presentaré tipos de datos escalares. Cubriré la segunda categoría en el próximo artículo.
Aquí hay una breve descripción de las cuatro categorías amplias de tipos de datos escalares en Rust:
- entero: almacenar números enteros. Hay subtipos para cada caso de uso específico.
- flota: Almacena números con valores decimales. Hay dos subtipos según el tamaño.
- cifra: Almacena un solo carácter codificado en UTF-8. (Sí, puede almacenar emoji* en caracteres).
- valor booleano: almacenar un
true
ofalse
(Por desacuerdo sobre siSí
true
o simétodo
false
.)
entero
Un número entero en el contexto de un lenguaje de programación se refiere a un número entero. Los enteros en Rust son firmar o no firmadoLos enteros sin signo solo pueden almacenar 0 y números positivos, mientras que los enteros con signo pueden almacenar números negativos, 0 y números positivos.
💡
Los enteros con signo van desde -(2n-1)
Este rango termina con (2n-1)-1
Del mismo modo, los enteros sin signo van desde y
(2n)-1
.
Los siguientes tipos de enteros están disponibles según el signo y la longitud:
Como puede ver, Rust tiene enteros con y sin signo de longitud 8, 16, 32, 64 e incluso 128.
entero y *size
Varía dependiendo de la arquitectura de la computadora.En un microcontrolador de 8 bits, es *8
En máquinas heredadas de 32 bits, es *32
En los sistemas modernos de 64 bits, es *64
.
uso de algo *size
Se utiliza para almacenar principalmente datos relacionados con la memoria (dependientes de la máquina), como punteros, compensaciones, etc.
💡
Cuando no especifica explícitamente un subconjunto del tipo Integer, el compilador de Rust inferirá que es del tipo i32
por defecto.Obviamente, si el valor es mayor o menor que lo i32
Está bien esperar, el compilador de Rust generará un error cortésmente y le pedirá que anote manualmente el tipo.
Rust no solo le permite almacenar números enteros en decimal, sino también en binario, octal y hexadecimal.
Para una mejor legibilidad, puede usar guiones bajos _
Como reemplazo de la coma al escribir/leer números grandes.
fn main() {
let bin_value = 0b100_0101; // use prefix '0b' for Binary representation
let oct_value = 0o105; // use prefix '0o' for Octals
let hex_value = 0x45; // use prefix '0x' for Hexadecimals
let dec_value = 1_00_00_000; // same as writing 1 Crore (1,00,00,000)
println!("bin_value: {bin_value}");
println!("oct_value: {oct_value}");
println!("hex_value: {hex_value}");
println!("dec_value: {dec_value}");
}
He almacenado el número decimal 69 en forma binaria, forma octal y forma hexadecimal en variable bin_value
, oct_value
y hex_value
respectivamente.en la variable dec_value
, he almacenado el número 10 crore (10 millones) con comas subrayadas según el sistema de numeración indio.Para aquellos más familiarizados con el sistema de numeración internacional, puede escribir esto como 10_000_000
.
Después de compilar y ejecutar este binario, obtengo el siguiente resultado:
bin_value: 69
oct_value: 69
hex_value: 69
dec_value: 10000000
número de coma flotante
Los números de coma flotante, o más comúnmente «float(s)» son un tipo de datos que contiene números con valores fraccionarios (cosas después del punto decimal).
A diferencia de los tipos enteros en Rust, los números de punto flotante solo tienen dos tipos de subconjuntos:
f32
: tipo de punto flotante de precisión simplef64
: Tipo de punto flotante de precisión doble
Al igual que el tipo Integer en Rust, cuando Rust infiere un tipo de variable que parece un flotador, se le asigna f64
tipo.Esto es porque f64
relación de tipos f32
tipo es casi tan rápido como f32
Introduzca la mayoría de las operaciones informáticas.tenga en cuenta tipo de datos de punto flotante (f32
y f64
) Sí firmar.
📋
fn main() {
let pi: f32 = 3.1400; // f32
let golden_ratio = 1.610000; // f64
let five = 5.00; // decimal point indicates that it must be inferred as a float
let six: f64 = 6.; // even the though type is annotated, a decimal point is still
// **necessary**
println!("pi: {pi}");
println!("golden_ratio: {golden_ratio}");
println!("five: {five}");
println!("six: {six}");
}
mira atentamente 5día Cable.Aunque he anotado el tipo de la variable six
I necesidad Utilice al menos un punto decimal.si tienes algo atrás El punto decimal lo decides tú.
La salida de este programa es muy predecible… ¿o no?
pi: 3.14
golden_ratio: 1.61
five: 5
six: 6
En el resultado anterior, es posible que haya notado que al mostrar el valor almacenado en la variable pi
, golden_ratio
y five
los ceros finales que especifiqué en la declaración de variables se pierden.
Si bien esos ceros no son borrarellos estan pasando println
macro. Así que no, Rust no manipula el valor de la variable.
cifra
Puede almacenar un solo carácter en una variable, el tipo es simplemente char
Al igual que en los lenguajes de programación tradicionales de los años 80, puedes almacenar caracteres ASCII. Pero Rust también extiende el tipo de carácter para almacenar caracteres UTF-8 válidos. Esto significa que puedes almacenar emoji en un solo carácter 😉
💡
No es posible almacenar dicho emoji en una sola variable de Rust de tipo carácter.
fn main() {
let a="a";
let p: char="p"; // with explicit type annotation
let crab = '🦀';
println!("Oh look, {} {}! :{}", a, crab, p);
}
Como puede ver, he almacenado los caracteres ASCII «a» y «p» en variables a
y p
También almacené en una variable un carácter UTF-8 válido, el emoji de cangrejo crab
Luego imprimo los caracteres almacenados en cada variable.
Aquí está la salida:
Oh look, a 🦀! :p
valor booleano
El tipo booleano en Rust solo almacena uno de dos valores posibles: true
o false
Si desea anotar el tipo, utilice bool
para representar el tipo.
fn main() {
let val_t: bool = true;
let val_f = false;
println!("val_t: {val_t}");
println!("val_f: {val_f}");
}
El código anterior, cuando se compila y ejecuta, produce el siguiente resultado:
val_t: true
val_f: false
Bono: conversión de tipo explícito
En un artículo anterior sobre variables en el lenguaje de programación Rust, mostré una rutina de conversión de temperatura muy básica. Allí, mencioné que Rust no permite conversiones de tipos implícitas.
Pero eso no significa que Rust no permita claramente conversión de tipo 😉
Para realizar una conversión de tipo explícita, as
Utilice la palabra clave seguida del tipo de datos al que se debe convertir el valor.
Aquí hay un programa de demostración:
fn main() {
let a = 3 as f64; // f64
let b = 3.14159265359 as i32; // i32
println!("a: {a}");
println!("b: {b}");
}
En la línea 2, en lugar de «3.0», uso después de «3» as f64
significa que quiero que el compilador convierta el tipo «3» (entero) en un número de coma flotante de 64 bits.igual que 3camino Cable.Pero aquí, la conversión de tipo es con pérdidassignifica que el elemento decimal es completamente desaparecidoen lugar de almacenar 3.14159265359
que simplemente se almacena como 3
.
Esto se puede verificar desde la salida del programa:
a: 3
b: 3
en conclusión
Este artículo presenta tipos de datos primitivos/escalares en Rust. Hay cuatro tipos de datos principales: entero, coma flotante, carácter y booleano.
Los enteros se utilizan para almacenar números enteros y tienen varios subtipos dependiendo de si están firmados o no y de su longitud. Los flotantes se utilizan para almacenar números con algún valor fraccionario y tienen dos subtipos basados en la longitud. El tipo de datos de caracteres se utiliza para almacenar un único carácter codificado en UTF-8 válido.Finalmente, el booleano se usa para almacenar true
o false
valor.
En el próximo capítulo, analizaré los tipos de datos compuestos, como matrices y tuplas. Manténganse al tanto.