Forem: Héctor David Leiva Gamboa

Día 6/365. Control de flujo: if, else, y expresiones.

Héctor David Leiva Gamboa — Mon, 06 Jan 2025 22:06:55 +0000

En esta ocasión, aprendí a realizar if y else, y cuál es la diferencia entre una expresión y una declaración.

Primero, ¿cómo es la estructura básica de un if y un else?

if condicion {
} else {
}

En la parte que dice condicion, hay que realizar cualquier tipo de comparación o pasar un booleano. Ahora bien, en lenguajes como C++ había que poner paréntesis () para hacer la comparación, pero en Rust no hace falta. Es algo que extraño, pero hay que acostumbrarse. El uso de un condicional es muy intuitivo, ya que se utilizan los mismos comparadores de siempre.

Además, estudié una cosa más: las expresiones y la diferencia con una declaración. Cuando declaras una variable, lo haces directamente, por ejemplo: x = 1. Pero en Rust (no sé si en otros lenguajes también), una variable puede tener un valor asignado como resultado de una comparación:

let y = if x == 1 { true } else { false };

Esto puede ser útil, aunque en otros lenguajes que no tienen esta funcionalidad se puede hacer con una función, lo cual consume más espacio. Este enfoque, en cambio, es más compacto.

Ahora bien, esta parte fue un poco complicada, ya que tuve algunos errores al hacerlo, pero el compilador me ayudó a resolverlos. Se trata de las funciones. Como todavía no sé mucho sobre ellas, se me complicó un poco. Aquí dejo dos ejemplos y sus diferencias:

fn main() {
   let x = true;
   println!("{} Rust", mensaje(x));
}

fn mensaje(comparacion: bool) -> &'static str {
   if comparacion {
      "Hola"
   } else {
      "Adiós"
   }
}

Esta es solo una función que devuelve un string (-> &'static str) y que recibe como entrada una variable. Esto es muy importante, ya que depende de la entrada de la variable. En este caso, la terminal nos devuelve: Hola Rust.

Ahora, con el siguiente ejemplo, que tomó un poco más de tiempo hacerlo:

fn main() {
   println!("{} Rust", mensaje(&false));
}

fn mensaje(comparacion: &bool) -> &'static str {
   if *comparacion {
      "Hola"
   } else {
      "Adiós"
   }
}

La principal diferencia es que la entrada es directamente un parámetro por referencia y no una variable. Por esta razón, Rust nos obliga a no duplicar este parámetro. ¿Por qué duplicar un parámetro si podemos usarlo en el mismo espacio en la memoria RAM? Por esto, debemos usar tanto los & como el *. El & evita duplicar el valor en un espacio de memoria, mientras que el * permite acceder al valor almacenado en la RAM.

Día 5/365. Variables, mutabilidad y sombras.

Héctor David Leiva Gamboa — Sun, 05 Jan 2025 16:48:35 +0000

Ahora vamos a hablar del comportamiento de un dato dentro de la memoria. Como bien sabe un programador, creamos datos dentro de la memoria, y algunas veces tenemos acceso total a ella. Rust, al tener esta característica, nos permite crear variables y modificarlas a nuestro placer, siguiendo algunas reglas, como el tipo de variable que estamos utilizando. En este caso, hay tres tipos de variables que pude observar:

Variables Inmutables

Estas variables no se pueden cambiar de una forma fácil, ya que son inmutables por razones de seguridad.
let x = 5;
En este caso, x es igual a 5, pero si intentamos cambiarlo a x = 6, el programa nos dará un error por motivos de seguridad.

Variables Mutables

Ahora vamos con las variables que se pueden cambiar sin ningún tipo de problema: las variables mutables. La forma de declarar estas variables es la siguiente:
let mut y = 'a';
Aquí usamos la palabra clave mut, que indica que la variable puede mutar. Sin embargo, hay una regla: debe permanecer del mismo tipo. Es decir, si es un char, no se puede cambiar a un i8 (entero de 8 bits).
Por ejemplo:
y = 'b';
Ahora es intuitivo ver cómo podemos cambiar el valor de la variable.

Sombras

Este tipo de variables es un poco especial, y aún no estoy seguro de dónde se podría usar exactamente. Por ejemplo, tenemos una variable inmutable llamada x (como hicimos anteriormente) con el valor 5. Si quisiéramos cambiar este valor, podríamos crear otra variable con el mismo nombre, sobrescribiéndola:
let x = 6;
Ahora, x tiene el valor 6, y el valor anterior (5) ha desaparecido. Es como si hubiéramos sobrescrito la variable. Sin embargo, parece que este proceso de sobrescribir una variable es más costoso que simplemente cambiar su valor.

La razón por la que se llama "sombra" es porque, si este cambio ocurre dentro de un bloque (por ejemplo, un if o un while), fuera del bloque la variable x seguirá teniendo su valor original (5), no el nuevo valor (6). Esto puede proporcionar un punto adicional de seguridad.

Día 4/365. Tipos de datos en Rust: Escalares y compuestos.

Héctor David Leiva Gamboa — Sun, 05 Jan 2025 04:57:48 +0000

Rust organiza los tipos de datos en dos categorías principales: Escalares y Compuestos. Este diseño busca maximizar la seguridad y eficiencia en el manejo de datos. Aquí te explico brevemente cada categoría y algunas funcionalidades clave.

Tipos escalares

Los tipos escalares representan un solo valor. Rust incluye cuatro tipos principales:
Enteros (i8, u8, i32, etc.): Valores positivos o negativos con tamaños específicos.
Punto flotante (f32, f64): Para números decimales.
Booleanos (bool): Representan true o false.
Caracteres (char): Representan un carácter Unicode, como 'a' o '😊'.

Son ideales para cálculos simples o datos básicos.

Tipos compuestos

Los tipos compuestos agrupan múltiples valores:

Tuplas: Colecciones de valores heterogéneos, útiles para agrupar datos relacionados.

let persona: (&str, i32) = ("Juan", 30);
println!("Nombre: {}, Edad: {}", persona.0, persona.1);

Arreglos ([T; N]): Almacenan valores homogéneos con tamaño fijo.

let numeros = [1, 2, 3];
println!("Primer número: {}", numeros[0]);

Vectores (Vec): Una colección dinámica para valores del mismo tipo. Perfectos cuando el tamaño de los datos es variable.

let mut vec = Vec::new();
vec.push(10);
vec.push(20);
println!("{:?}", vec);

Día 3/365. Estructura básica de un programa en Rust.

Héctor David Leiva Gamboa — Fri, 03 Jan 2025 20:28:52 +0000

Primero que todo, Rust es un lenguaje de bajo nivel si no estoy equivocado, y si no se han dado cuenta, es parecido a C o C++. Esto es porque los programadores pueden modificar la memoria en el programa. Sin embargo, Rust tiene un compilador superior, ya que permite realizar pruebas antes de mover el programa. Esto nos evita problemas futuros como segmentos de memoria no válidos, un inconveniente común en C++ u otros lenguajes. Rust nos indica dónde están esos problemas.

Comentarios

Los comentarios son fundamentales en Rust, como se mencionó el día 2. Rust puede generar su propia documentación a partir de los comentarios dentro de las funciones. La forma de escribir comentarios es la siguiente: // Comentarios

Funciones

No profundizaremos en cómo se hacen las funciones o módulos, solo su estructura básica.

fn main(){
}

Esta es la estructura básica de una función en Rust. Por ahora, no sé si hay tipos de funciones como en C++, donde al crear una función hay que devolver un parámetro del mismo tipo que la función. Por ejemplo, si la función es de tipo booleano, es obligatorio retornar un booleano.

Variables

Solo sé cómo declarar un tipo de variable, que es let. Esta variable puede ser un string, un número, un carácter, etc. A mi parecer, es similar a Python, ya que se puede definir una variable sin especificar su tipo. Un ejemplo sería:

let palabra="Hola";
let numero="2025";

Declaré dos variables, pero no especifiqué su tipo.

Imprimir en la terminal

Esto es básico para mostrar información en una terminal: println!();. Su estructura es similar a la de Python con print, y el ln significa line next (siguiente línea), lo cual es muy útil a mi parecer. Al final, se debe añadir un ;, como en Java o C++. Si no se coloca este ; al final de cada instrucción, no se realizará la compilación y se mostrará un error.

Funciones y Macros

Hay una diferencia entre funciones y macros, ya que hay un símbolo extraño en println!, que es !. Este símbolo significa que la función que estamos llamando es una macro. Una macro puede recibir una cantidad variable de parámetros: 1, 6, o los que se necesiten. Por otro lado, las funciones normales requieren que se introduzca la cantidad exacta de parámetros; de lo contrario, se generará un error. Esto puede ser útil, pero también es posible hacer que las funciones normales reciban una lista, lo que permite realizar algo similar a una macro en una función normal.

Día 2/365. Cargo?

Héctor David Leiva Gamboa — Thu, 02 Jan 2025 23:04:12 +0000

Ayer descubrí un comando que no conocía: cargo. Me pregunté qué significaba y para qué servía. Hoy quiero explicar qué es Cargo desde mi perspectiva, basándome en la documentación oficial de Rust y en foros de programación.

¿Qué es Cargo?

Cargo es un gestor de proyectos y dependencias para Rust. Si has trabajado con herramientas como npm en Node.js o pip en Python, Cargo cumple un rol similar. Se encarga de gestionar tareas clave en el desarrollo con Rust, como:

Crear proyectos.
Administrar dependencias.
Compilar el código.
Ejecutar pruebas.
Generar documentación.

Empezar con Cargo

Para crear un nuevo proyecto en Rust, utiliza el comando:
cargo new "nombre"
Esto genera una estructura de carpetas básica para comenzar tu proyecto.

Comandos útiles de Cargo

A continuación, presento una lista de comandos esenciales que puedes usar en la terminal. Aunque Cargo no tiene una interfaz gráfica, su uso en la terminal es intuitivo y fácil de aprender con la práctica.

cargo new "nombre": Crea un nuevo proyecto.
cargo build: Compila tu proyecto.
cargo run: Compila y ejecuta tu programa.
cargo test: Ejecuta pruebas para verificar errores en tu código.
cargo fmt: Formatea tu código para mantener un estilo limpio y consistente.
cargo clippy: Analiza tu código para encontrar posibles mejoras y hacerlo más eficiente.
cargo doc: Genera documentación a partir de los comentarios en tu código.
cargo clean: Elimina archivos temporales generados durante la compilación para liberar espacio.

Algo que realmente me gusta de Rust es su compilador. Es muy práctico y, hasta ahora, ha demostrado ser bastante amigable para las personas que recién comienzan con el lenguaje. Actualmente, espero que siga siendo así en el futuro, ya que no me ha dado ningún problema.

Una de las cosas que más aprecio es cómo el compilador maneja los errores: no solo señala dónde está el problema, sino que también proporciona sugerencias claras sobre cómo resolverlo. Esto lo convierte en una herramienta invaluable para aprender y desarrollar proyectos con confianza.

Día 1/365. Instalar Rust en ArchLinux

Héctor David Leiva Gamboa — Wed, 01 Jan 2025 21:08:47 +0000

Objectivo

Hoy como primer dia, es facil, como instalar Rust en ArchLinux es el primer paso y como imprimir un texto simple y luego como ejecutar el programa

Instalar Rust en ArchLinux:

sudo pacman -S rust
rustc --version
cargo --version

Realizar el programa

cargo new dia_1

Aqui nos creara una carpeta del proyecto es algo asi.
.
├── Cargo.toml
├── src
└── main.rs
Solo tienes que editar main.rs.

fn main() {
   println!("Hello, word");
}

Reto de Rust 365 días, 2025!!

Héctor David Leiva Gamboa — Wed, 01 Jan 2025 20:24:25 +0000

Hola, soy un universitario en el TEC de Costa Rica, estudio Ingeniería Mecatrónica y quiero aprender un nuevo idioma de programación. Un día vi Rust, no me puse a investigar mucho en ese momento, pero ahora he decidido crear un reto de 365 días aprendiendo Rust.

Mi plan es el siguiente:

Aprender Rust en un año.
Realizar proyectos sencillos.

(No sé mucho sobre Rust, así que esto es algo general y, en el futuro, modificaré esta idea).

Lo más importante para mí es aprender al menos una cosa cada día, todos los días del año 2025, y publicarlo para recibir apoyo y formar una comunidad.