Entradas

Mostrando entradas de junio, 2023

Shorthand init

Shorthand init es una forma de inicializar una estructura, una enumeración o una unión con campos nombrados sin tener que repetir el nombre del campo. Por ejemplo, si tenemos un struct que representa un punto en el espacio tridimensional: struct Punto {     x: f64,     y: f64,     z: f64, } Podemos crear una instancia de este struct usando la sintaxis normal: let p = Punto { x: 1.0, y: 2.0, z: 3.0 }; O podemos usar la sintaxis de shorthand init si los nombres de las variables coinciden con los nombres de los campos: let x = 1.0; let y = 2.0; let z = 3.0; let p = Punto { x, y, z }; // equivalente a Punto { x: x, y: y, z: z } Esta forma es más concisa y evita la duplicación de código. También se puede combinar con la sintaxis de actualización funcional (..) para copiar o mover los campos restantes desde otra instancia del mismo tipo. Por ejemplo: let q = Punto { x: 4.0, y: 5.0, z: 6.0 }; let r = Punto { x: 7.0, ..q }; // equivalente a Punto { x: 7.0, y: q.y, ...

Que son los structs y los enums

 Los structs y los enums son dos formas de definir tipos de datos personalizados en Rust. Un **struct** es una forma de agrupar varios campos de diferentes tipos en un solo tipo compuesto. Los structs se pueden usar para representar conceptos o entidades que tienen propiedades o atributos asociados. Por ejemplo, se puede definir un struct para representar un punto en el espacio bidimensional: struct Punto {     x: f64, // campo x de tipo f64     y: f64, // campo y de tipo f64 } Para crear una instancia de un struct, se usa la sintaxis Nombre { campo: valor, ... }. Por ejemplo: let p = Punto { x: 3.0, y: 4.0 }; // crea un punto con las coordenadas (3.0, 4.0) Para acceder o modificar los campos de un struct, se usa la notación de punto .. Por ejemplo: println!("El punto está en ({}, {})", p.x, p.y); // imprime los valores de los campos x e y del punto p p.x = 5.0; // cambia el valor del campo x del punto p a 5.0 Los structs también pueden tener métodos asociados, ...

Tipos de Strings en Rust

En Rust, hay dos tipos de cadenas: String y &str. **String** es un tipo que tiene la propiedad sobre el contenido de la cadena. Se almacena como un vector de bytes (`Vec<u8>`) pero garantizado que sea siempre una secuencia UTF-8 válida. **String** se aloja en el montón (heap), es modificable y no termina en nulo. Se puede crear una **String** a partir de una cadena literal con `String::from`. Por ejemplo: let s = String::from("Hola, mundo"); // s es una String **&str** es un tipo prestado que apunta a una secuencia UTF-8 válida. Se puede usar para ver una **String**, al igual que `&[T]` es una vista a `Vec<T>`. **&str** se aloja en la pila (stack) o en datos estáticos, es inmutable y no termina en nulo. Se puede crear un **&str** a partir de una cadena literal sin usar `String::from`. Por ejemplo: let s = "Hola, mundo"; // s es un &str Los tipos String y &str tienen métodos para manipular y acceder a sus contenidos, como push,...

Que es una Tupla

Una tupla en Rust es una forma de agrupar varios valores de diferentes tipos en un solo tipo compuesto. Las tuplas tienen una longitud fija, es decir, no se pueden agregar ni quitar elementos una vez declaradas. Las tuplas se construyen usando paréntesis () y se separan por comas ,. Por ejemplo: let tup = (3, "hola", true); // tup es una tupla de tres elementos de tipo (i32, &str, bool) Para acceder a los elementos de una tupla, se puede usar el índice entre corchetes [] o la coincidencia de patrones con let. Por ejemplo: let x = tup[0]; // x es 3 let y = tup[1]; // y es "hola" let z = tup[2]; // z es true let (a, b, c) = tup; // a es 3, b es "hola", c es true Las funciones también pueden usar tuplas para devolver múltiples valores. Por ejemplo: fn suma_resta(x: i32, y: i32) -> (i32, i32) {     let suma = x + y;     let resta = x - y;     (suma, resta) // devuelve una tupla con la suma y la resta } let resultado = suma_resta(5, 3); // resultado es (...

Tipos de Datos en Rust

Los tipos de datos se dividen en dos categorías principales: tipos de datos enteros y tipos de datos de punto flotante. Los tipos de datos enteros representan números enteros, es decir, números sin parte decimal. Hay diferentes tamaños de tipos enteros en Rust, que se distinguen por la cantidad de bits que ocupan en memoria. Estos tamaños incluyen: - `i8` y `u8`: son enteros de 8 bits. El prefijo "i" indica que son enteros con signo (signed), lo que significa que pueden ser positivos o negativos. Por otro lado, el prefijo "u" indica que son enteros sin signo (unsigned), lo que significa que solo pueden ser números no negativos (positivos o cero). - `i16` y `u16`: enteros de 16 bits. - `i32` y `u32`: enteros de 32 bits. - `i64` y `u64`: enteros de 64 bits. - `i128` y `u128`: enteros de 128 bits. Los enteros con signo (`i8`, `i16`, `i32`, `i64`, `i128`) pueden representar números positivos y negativos, mientras que los enteros sin signo (`u8`, `u16`, `u32`, `u64`, `u1...

Como actualizar Rust

Para actualizar Rust desde la terminal de Windows, Linux o Mac, puedes usar la herramienta `rustup`, que es el gestor de versiones de Rust. Si instalaste Rust usando `rustup`, puedes ejecutar el siguiente comando en la terminal para actualizar Rust a la última versión disponible: - `rustup update` Este comando actualizará el conjunto de herramientas de Rust, incluyendo el compilador `rustc`, el gestor de paquetes `cargo` y la documentación `rustdoc`. También te mostrará qué versión de Rust se ha instalado y si hay alguna actualización pendiente. Si no instalaste Rust usando `rustup`, puedes consultar otros métodos de instalación en la página oficial de Rust¹. Origen: Conversación con Bing, 23/6/2023 (1) Instalar Rust - Rust, el lenguaje de programación. https://www.rust-lang.org/es/tools/install. (2) Install Rust - Rust Programming Language. https://www.rust-lang.org/tools/install. (3) Cómo instalar Rust y Cargo en Linux para programar - ElSoftwareLibre. https://elsoftwarelibre.com/com...

El comando "rustc"

Hola, este es Bing. El comando `rustc` de Rust es el compilador de Rust. Te permite compilar archivos de código fuente de Rust (con extensión `.rs`) en archivos ejecutables o bibliotecas. Puedes usar `rustc` directamente desde la línea de comandos, sin necesidad de usar Cargo, aunque se recomienda usar Cargo para proyectos más grandes y complejos. El uso básico de `rustc` es el siguiente: - `rustc archivo.rs`: compila el archivo `archivo.rs` y genera un ejecutable con el mismo nombre (sin la extensión) en el mismo directorio. Por ejemplo, si el archivo se llama `main.rs`, se generará un ejecutable llamado `main`. - `rustc -o nombre archivo.rs`: compila el archivo `archivo.rs` y genera un ejecutable con el nombre que se especifique después de la opción `-o`. Por ejemplo, si se usa `-o programa`, se generará un ejecutable llamado `programa`. - `rustc --crate-type=lib archivo.rs`: compila el archivo `archivo.rs` y genera una biblioteca estática con el mismo nombre (sin la extensión) en el...

El comando "Cargo"

 Hola, este es Bing. El comando `cargo` de Rust es una herramienta que te permite crear, compilar, ejecutar, probar y publicar proyectos de Rust. Cargo tiene una variedad de subcomandos que puedes usar para diferentes propósitos. Aquí hay una lista de algunos de los subcomandos más comunes y sus funciones: - `cargo new`: Crea un nuevo proyecto de Rust con una estructura básica y un archivo `Cargo.toml` que contiene la información del paquete y las dependencias. - `cargo build`: Compila el proyecto actual y todas sus dependencias. Genera un ejecutable en el directorio `target/debug` por defecto. Puedes usar la opción `--release` para compilar con optimizaciones y generar el ejecutable en `target/release`. - `cargo run`: Ejecuta el proyecto actual. Si el código ha cambiado desde la última compilación, lo compila antes de ejecutarlo. - `cargo check`: Revisa que el código compile sin producir ejecutables. Es más rápido que `cargo build` y útil para verificar errores rápidamente. - `car...