Tutoriales

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 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 enteros con signo van desde -(2n-1) Este rango termina con (2n-1)-1Del 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:

Tipos de datos enteros en Rust

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.

💡

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 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.

📋

El lenguaje de programación Rust almacena números de punto flotante de acuerdo con el estándar IEEE 754 para representación y aritmética de números de punto flotante.
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 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 😉

💡

Algunos emoji son una mezcla de dos emoji existentes. Un buen ejemplo es el emoji «Corazón Ardiente»: ❤️‍🔥. Este emoji se creó combinando dos emoji usando un conector de ancho cero: ❤️ + 🔥 = ❤️‍🔥

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 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 3camino 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.

LEER  Comando cat de Linux para eliminar bat

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba