Rust es un lenguaje de programación moderno de tipo estático diseñado para el rendimiento, la confiabilidad y la seguridad. Al igual que en otros lenguajes de tipos estáticos, los tipos de datos de Rust se declaran en el momento de la compilación. Esto facilita la detección de errores de tipo antes de ejecutar el código.
Rust ofrece tipos escalares, compuestos, de referencia, estructuras, enumeraciones y cadenas. Su inferencia de tipo proporciona funcionalidad para escribir código conciso mientras mantiene la seguridad de un lenguaje de tipado estático.
Enteros en Rust
Rust proporciona tipos enteros con y sin signo clasificados según la cantidad de bits. Los tipos de enteros con signo son i8, i16, i32, y i64 que representan enteros con signo de 8 bits, 16 bits, 32 bits y 64 bits, respectivamente. También admite tipos enteros sin signo son u8, u16, u32, y u64, que representa enteros sin signo de 8 bits, 16 bits, 32 bits y 64 bits.
// enteros con signo
dejar a: i8 = -10;
dejar b: i16 = -2048;
dejar c: i32 = -2147483648;
dejar d: i64 = -9223372036854775808;
// enteros sin signo
dejar mi: u8 = 255;
dejar f: u16 = 65535;
dejar g: u32 = 4294967295;
dejar h: u64 = 18446744073709551615;
Rust usa el i32 type para literales enteros por defecto.
Tipos de punto flotante de óxido
El óxido proporciona f32 y f64 como tipos de punto flotante que representan números de punto flotante de precisión simple y precisión doble. El f32 tipo utiliza 32 bits para almacenar valores, y el f64 tipo utiliza 64 bits.
Los números de punto flotante en Rust siguen el estándar IEEE 754 para la aritmética de punto flotante.
dejar un = 3.14159265358979323_f32;
dejar segundo = 2.718281828459045235_f64;
Uso de valores booleanos de Rust
El óxido proporciona una bool escribir para representar verdadero o FALSO valores. Los booleanos se utilizan a menudo en instrucciones de flujo de control y condicionales para la toma de decisiones del programa.
dejar variable_1: bool = verdadero;
dejar variable_2: bool = FALSO;
Puede comparar valores booleanos con el operador de igualdad, ==, y el operador de desigualdad, !=. Rust no define los operadores de comparación, , <=, y >=, para bool valores.
dejar variable_1: bool = verdadero;
dejar variable_2: bool = FALSO;
si variable_1 == variable_2 {
imprimir!("variable_1 es igual a variable_2");
} demássi variable_1 != variable_2 {
imprimir!("variable_1 no es igual a variable_2");
}
El tipo de char
el óxido carbonizarse type representa un único valor escalar Unicode que puede representar cualquier carácter en el estándar Unicode. Puede especificar un carbonizarse valor usando comillas simples.
// Declarando un valor de char
dejar c = 'a';
El carbonizarse type es útil para trabajar con emojis en Rust.
Tuplas en Rust
La estructura de datos de tupla le permite agrupar más de un valor en un solo valor compuesto. Estos valores pueden ser del mismo tipo o de diferentes tipos. Puede declarar tuplas escribiéndolas como una lista de valores separados por comas y entre paréntesis.
Así es como puede declarar una tupla con números enteros de 32 bits, cadenas y valores float64.
dejar arriba: (i32, &str, f64) = (500, "Hola", 3.14);
Las tuplas tienen una longitud fija y puede usarlas para devolver múltiples valores de una función o pasar múltiples valores a funciones como un solo argumento.
Puede acceder a elementos individuales de una tupla al desestructurarla mediante coincidencia de patrones o acceder directamente a elementos individuales mediante la sintaxis de punto (.) y un índice.
Así es como puede acceder a elementos individuales de una estructura mediante la coincidencia de patrones:
dejar mi_tupla = (10, "¡Hola Mundo!", FALSO);dejar (x, y, z) = mi_tupla;
imprimir!("El primer elemento es: {}", X);
imprimir!("El segundo elemento es: {}", y);
imprimir!("El tercer elemento es: {}", z);
Así es como puede acceder a elementos individuales usando la notación de puntos:
dejar mi_tupla = (10, "¡Hola Mundo!", FALSO);
imprimir!("Elprimeroelementoes: {}", mi_tupla.0);
imprimir!("Elsegundoelementoes: {}", mi_tupla.1);
imprimir!("Elterceroelementoes: {}", mi_tupla.2);
Las tuplas son muy útiles cuando se agrupan datos relacionados en un solo valor. También pueden mejorar la legibilidad de su código si los usa con moderación.
Matrices en Rust
Una matriz es una colección de elementos del mismo tipo con una longitud fija. Las matrices de Rust se escriben como una lista de valores entre corchetes, separados por comas.
Así es como puede declarar matrices en Rust:
dejar ar = [1, 2, 3, 4, 5];
No puede cambiar la cantidad de elementos en una matriz una vez que la haya declarado, pero puede acceder, modificar y manipular elementos individuales de una matriz mediante la indexación.
dejar mut mi_matriz = [1, 2, 3, 4, 5];// Accediendo a elementos
imprimir!("Elprimeroelementoes: {}", mi_matriz[0]);// Modificando elementos
mi_matriz[0] = 100;
imprimir!("Elprimeroelementodespuésmodificaciónes: {}", mi_matriz[0]);// Bucle sobre una matriz y manipulación de elementos
paraien 0..mi_matriz.len() {
mi_matriz[i] *= 2;
}
// imprimiendo la matriz
imprimir!("La matriz después de la manipulación: {:?}", mi_matriz);
Las matrices de óxido son almacenado en la pila y tener una asignación de memoria contigua, por lo que acceder a los elementos de una matriz es rápido y eficiente. Esto hace que las matrices sean adecuadas para situaciones en las que necesita almacenar y procesar muchos elementos.
Trabajar con rebanadas de óxido
Un segmento es una estructura de datos que permite referenciar una secuencia contigua de elementos en una colección. Los cortes están representados por el &[T] type, donde T es el tipo de elementos almacenados en el segmento.
fn principal(){
// declarar una matriz
dejar mi_matriz = [1, 2, 3, 4, 5];// crea un segmento de la matriz
dejar mi_rebanada = &mi_matriz[1..3];
// imprime la rebanada
imprimir!("Rebanada: {:?}", mi_rebanada);
}
Observe cómo la sintaxis de rango, .., extrae un segmento de una matriz utilizando el índice inicial y un índice mayor que el final:
Los segmentos son dinámicos, por lo que Rust puede determinar su longitud en tiempo de ejecución. También puede pasar segmentos como argumentos a funciones sin necesidad de asignación de almacenamiento dinámico.
Por lo general, usará segmentos para operaciones de cadena y para pasar subconjuntos de datos a funciones. Son una herramienta poderosa y eficiente para administrar colecciones en Rust, proporcionando una alternativa más flexible a las matrices.
Puede crear aplicaciones web frontend impulsadas por WebAssembly en Rust
El conocimiento de los tipos de datos es fundamental para su recorrido por Rust, ya que los utilizará para la mayoría de las operaciones mientras crea aplicaciones.
WebAssembly es un formato binario de bajo nivel que se ejecuta en navegadores web modernos, con un rendimiento casi nativo. Le permite escribir código en muchos idiomas diferentes y transpilarlo a WebAssembly.
WebAssembly está ganando adopción a través de Rust. Hay muchos marcos como Yew, Sycamore y Seed que puede usar para crear interfaces con tecnología WebAssembly con Rust.