Tipos de datos de óxido
Los tipos de datos son una característica universal entre muchos lenguajes de programación y proporcionan un sólido bloque de construcción para los programas que construimos con él. Tenga en cuenta que cada idioma tiene sus propios tipos que pueden diferir de otros idiomas.
Como programadores, conocer los diversos tipos primitivos proporcionados por un lenguaje es más que crucial. Por lo tanto, para este tutorial, caminaremos por los diversos tipos en el lenguaje de programación de óxido.
Tipos primitivos de óxido
Hay dos categorías principales para tipos primitivos de óxido:
- Tipos escalar
- Tipos de compuestos
Sin embargo, realmente no importa si un tipo es escalar o compuesto, todo lo que necesita saber es cómo usarlo en sus programas.
Comencemos con los tipos más comunes y básicos en óxido:
Enteros
La primera categoría de tipos primitivos en óxido es enteros. Un entero es un tipo de número que no tiene un valor fraccional. Hay varios tipos de tipos enteros en óxido e incluyen:
- i8
- U8
- i16
- U16
- i32
- U32
- i64
- U64
- i128
- U128
- hacer
- utilizar
Cada tipo entero toma el formato de:
cartaLa carta en este caso denota si el número puede tener un signo. Si el tipo está firmado (i), puede tener un valor negativo. Si no firma (u), el número solo será positivo.
El valor numérico representa el tamaño en bits, el tipo ocupará en la memoria. Por ejemplo, un valor i32 representa un entero firmado de 32 bits.
El tipo de ISIZE o USIZE dependerá de la arquitectura en la que se ejecute el código. Si está en una arquitectura de 32 bits, el tipo ocupará 32 bits y 64 bits para arquitecturas de 64 bits.
NOTA: Asegúrese de mantener sus valores dentro del rango de sus tipos especificados. De lo contrario, tiene un desbordamiento que puede conducir a operaciones peligrosas.
El programa de ejemplo a continuación muestra cómo declarar y usar tipos de enteros en óxido.
fn main ()// tipos enteros
Sea i_8 = -128;
Deje u_8 = 127;
Sea i_16 = -32768;
Deje u_16 = 32767;
Sea i_32 = -2147483648;
Deje u_32 = 2147483647;
Sea i_64 = -9223372036854775808_i64;
Deje u_64 = 9223372036854775807_u64;
Sea i_128 = -170141183460469231731687303715884105728_i128;
Sea u_128 = 1701411834604692317316873037158844105727_u128;
Sea i_size = -9223372036854775808_isize;
Deje u_size = 9223372036854775807_usize;
println!("i_8 -> \ nu_8 -> \ ni_16 -> \ nu_16 -> \ ni_32 -> \ nu_32 -> \ ni_64 -> \ ni_64 -> \ Ni_128 -> \ nu_128 -> \ ni_size -> \ nu_size -> ", i_8, u_8, i_16, u_16, i_32, u_32, i_64, u_64, i_128, u_128, i_size, u_size);
El programa anterior muestra cómo declarar tipos int en óxido. Esto debería imprimir:
NOTA: Si no especifica el tipo al asignar un valor numérico, el óxido predeterminará un tipo I32.
De tipo flotante
El óxido tiene números de tipo flotante. Estos son números que incluyen valores de puntos flotantes o puntos decimales. Solo hay dos tipos de tipos flotantes en óxido: F32 y F64 que son valores de 32 bits y 64 bits.
El ejemplo de tipo flotante es como se muestra:
Deje que F_32 = 3.141_f32; // Tipo flotante de 32 bitsSea F_64 = 3.141; // tipo flotante de 64 bits
Si no especifica el tipo para un valor de punto flotante, Rust de forma predeterminada al tipo F64.
Booleanos
El otro tipo proporcionado por Rust es un booleano. Como todos los valores lógicos booleanos, tiene dos valores posibles: Verdadero o Falso. Un booleano es un byte de tamaño.
El ejemplo es como se muestra:
Deje var1 = verdadero;Sea var2 = false;
Tipo de caracter
El tipo de personaje se refiere a un solo carácter unicode. Tiene 4 bytes de tamaño. Por ejemplo, lo siguiente muestra varios tipos de tipos de Char Unicode.
Sea a = 'a';dejar emoji = '😊';
Sea pi = 'π';
Sea grande = '大';
Los ejemplos de código anteriores representan varios caracteres unicodeos.
Matrices
La segunda categoría de tipos primitivos en óxido son los tipos de compuestos. Una matriz es parte del tipo compuesto.
Una matriz se refiere a una colección ordenada de valores de tipos similares. El siguiente código muestra una matriz en Rust:
Let Carta: [&str; 5] = ["A", "B", "C", "D", "E"];En Rust, declaramos una matriz usando la palabra clave LET seguido del nombre de la variable, un color completo y el tipo y tamaño dentro de un soporte cuadrado.
Rodajas
Las rodajas son muy similares a las matrices, excepto que son dinámicas. A diferencia de una matriz, una porción puede crecer o encogerse en tamaño.
Un ejemplo es como se muestra:
dejar slc = [1,2,3,4,5];Tuplas
El otro tipo de compuestos tipos de datos en óxido es una tupla. Una tupla se define una secuencia heterogénea de valores. Una tupla puede contener valores de múltiples tipos a diferencia de una matriz. Las tuplas también tienen un pedido y se puede acceder a través de sus índices. Consulte nuestro tutorial sobre las tuplas de Rust para obtener más información.
Un ejemplo de una tupla de óxido es como se muestra a continuación:
dejar tup = (1,2,3,4,5); // sin anotación de tipoSea tup_letter: (i32, & str, f64, char) = (100, "hola", 3.141, 'A'); // Anotación de tipo explícito
En la primera tupla, dejamos que el compilador de óxido infiera el tipo basado en los valores proporcionados.
Para el segundo, le decimos explícitamente al compilador qué tipos queremos. Tenga en cuenta que la orden es importante en este tipo de declaración.
Conclusión
De este tutorial, notas que Rust nos proporciona un conjunto de tipos primitivos increíbles. Nos permiten manejar varios tipos de datos y controlar los datos que entran o salen de nuestras aplicaciones.
Gracias por leer!