Estos son valores booleanos comunes que pueden ser verdaderos o falsos.

personaje

Este tipo se caracteriza por el ancho de la broca. La longitud máxima admitida por Rust es de 128 bits.

Un entero con signo de tamaño variable (el tamaño depende del tamaño del puntero subyacente).

Entero sin signo de tamaño variable (el tamaño depende del tamaño del puntero subyacente).

ftipo de punto flotante de 32 bits

Tipo de punto flotante de 64 bits

Una matriz de tamaño fijo, T representa el tipo de elemento, N representa el número de elementos y es una constante no negativa en el momento de la compilación.

Una vista de tamaño dinámico de una secuencia contigua, donde T representa cualquier tipo.

Corte de cadenas, utilizado principalmente como referencia, es decir, &str

Las sucesiones finitas, T y U, pueden ser de diferentes tipos.

Una función que recibe un parámetro de tipo i32 y devuelve un parámetro de tipo i32. Las funciones también tienen un tipo.

fn agregar (a: u64, b: u64) -> u64 { un segundo } fn principal() { sea ​​a: u64 = 17; sea ​​b = 3; let resultado = agregar(a, b); println!("Resultado {}", resultado); }

fn principal() { sea ​​duplicador = |x| x * 2; dejar valor = 5; let two = doubler(valor); println!("{} duplicado es {}", valor, dos veces); dejar big_closure = |b, c| sea ​​z = bc; z * dos veces }; let some_number = big_closure(1, 2); println!("Resultado del cierre: {}", algún_número); }

fn principal() { let pregunta = "¿Cómo estás?"; dejar persona: String = "Bob".to_string(); let namaste = String::from("zd"); println!("{}! {} {}", nombre, pregunta, persona); }

En el código anterior, el tipo de persona y namaste es String y el tipo de pregunta es &str. Hay muchas formas de crear datos de tipo String. Los datos de tipo cadena se asignan en el montón. Los datos de tipo &str suelen ser un puntero a una cadena existente. Estas cadenas están en la pila y el montón, o pueden ser cadenas en el segmento de datos del código objeto compilado.

fn principal() { let Rust_is_awesome = verdadero; si el óxido_es_increíble { println!("Efectivamente"); } demás { println!("Bueno, ¡deberías probar Rust!"); } }

fn principal() { deja resultado = si 1 == 2 { "¿Esperar lo?" } demás { "El óxido tiene sentido" }; println!("¿Sabes qué? {}.", resultado); }

Cuando el valor a asignar se devuelve de la expresión if else, necesitamos usar un punto y coma como marca final. Por ejemplo, si es una expresión, entonces let es una declaración, que espera que tengamos un punto y coma al final.

fn req_status() -> u32 { 200 } fn principal() { dejar estado = req_status(); estado del partido { 200 => println!("Éxito"), 404 => println!("No encontrado"), otro => { println!("La solicitud falló con el código: {}", otro); } } }

fn principal() { sea ​​mut x = 1024; bucle { si x < 0 { romper; } println!("{} quedan más ejecuciones", x); x-= 1; } }

fn tonto_sub (a: i32, b: i32) -> i32 { dejar resultado mut = 0; 'incremento: bucle { si resultado == a { sea ​​mut dec = b; 'decremento: bucle { ifdec==0{ romper 'incremento; } demás { resultado -= 1; diciembre -= 1; } } } demás { resultado = 1; } } resultado } fn principal() { sea ​​a = 10; sea ​​b = 4; let resultado = tonto_sub(a, b); println!("{} menos {} es {}", a, b, resultado); }

fn principal() { imprimir!("Rango normal: "); para i en 0..10 { imprimir!("{},", i); } imprimir!(); print!("Rango inclusivo: "); para i en 0..=10 { imprimir!("(),", i); } }

En Rust, existen tres formas de declaración de estructura. La más simple de ellas es la estructura unitaria, que se declara utilizando la palabra clave struct, seguida de su nombre y termina con un punto y coma.

La segunda forma de estructura es la estructura de tupla, que tiene datos asociados. Cada uno de estos campos no tiene nombre, pero se hace referencia a ellos según su posición en la definición.

Las estructuras de tuplas son ideales para modelar datos con menos de 5 atributos. Cualquier elección distinta a esta obstaculizará la legibilidad y el razonamiento del código. Para tipos de datos con más de 3 campos, construya estructuras utilizando un lenguaje similar a C. Esta es la tercera forma y la más utilizada.

Las enumeraciones son una buena manera de hacer esto cuando necesitas modelar diferentes tipos de cosas. Se crea utilizando la palabra clave enum, seguida del nombre de la enumeración y un par de llaves. Dentro de las llaves podemos escribir todos los tipos posibles, es decir, variantes. Estas variantes se pueden definir con o sin datos, y los datos contenidos pueden ser de cualquier tipo, estructura, estructura de tupla o incluso un tipo de enumeración.

Podemos agregar comportamiento a una estructura definida usando dos mecanismos: funciones tipo constructor y métodos getter y setter.

Las enumeraciones se usan ampliamente en máquinas de estado y, cuando se usan con expresiones de coincidencia, pueden hacer que el código de transición de estado sea muy conciso. También se pueden utilizar para modelar tipos de errores personalizados.

Cada programa Rust requiere un módulo raíz. Para los archivos ejecutables, suele ser el archivo main.rs y, para las bibliotecas, suele ser el archivo lib.rs.

Los módulos pueden declararse dentro de otros módulos u organizarse en archivos y directorios.

Para que el compilador reconozca nuestro módulo, debemos usar la declaración mod de palabra clave. En nuestro módulo raíz, debemos usar la palabra clave use antes del nombre del módulo, lo que significa incluir el elemento en el alcance.

Los elementos definidos en un módulo son privados de forma predeterminada y deben exponerse a las personas que llaman mediante la palabra clave pub.

Las matrices tienen una longitud fija y pueden almacenar elementos del mismo tipo. Están representadas por [T, N], donde T representa cualquier tipo y N representa el número de elementos de la matriz. El tamaño de la matriz no puede representarse mediante una variable y debe ser un valor literal de uso.

subtema