Rust Fundamentals Series #3: Tipos de datos en Rust

En el último artículo sobre el lenguaje de programación Rust, analizamos variables, constantes y sombras.

Cubrir tipos de datos es natural ahora.

¿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 1Pero para entenderlo mientras leemos, usamos tipos de datos para ilustrar esos arena 1Muy malo.

Rust tiene dos tipos de tipos de datos:

1. tipo de datos escalares: Un tipo que solo almacena un único valor.
2. 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 o false(Por desacuerdo sobre si Sí true o si mé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 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 *8En 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.

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 simple
• f64: 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 5^día Cable.Aunque he anotado el tipo de la variable sixI 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 fivelos 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 charAl 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 😉

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 pTambién almacené en una variable un carácter UTF-8 válido, el emoji de cangrejo crabLuego 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 falseSi 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 3^camino Cable.Pero aquí, la conversión de tipo es con pérdidassignifica que el elemento decimal es completamente desaparecidoen lugar de almacenar 3.14159265359que 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.