El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Construyendo un Proyecto

Siguiente ►
►

En este módulo, aprenderemos cómo construir un proyecto en Rust desde cero. Este proceso incluye la creación de un nuevo proyecto, la organización del código, la gestión de dependencias y la compilación del proyecto. Al final de este módulo, tendrás una comprensión clara de cómo estructurar y construir proyectos en Rust de manera eficiente.

  1. Creación de un Nuevo Proyecto

1.1. Instalación de Cargo

Cargo es la herramienta de gestión de paquetes y compilación de Rust. Si has seguido los módulos anteriores, ya deberías tener Cargo instalado. Si no, puedes instalarlo siguiendo las instrucciones en Configuración del Entorno de Rust.

1.2. Crear un Proyecto Nuevo

Para crear un nuevo proyecto en Rust, utilizamos el comando cargo new. Este comando crea una estructura de directorios básica para tu proyecto.

cargo new my_project
cd my_project

Esto creará un directorio llamado my_project con la siguiente estructura:

my_project
├── Cargo.toml
└── src
    └── main.rs
  • Cargo.toml: Archivo de configuración de Cargo donde se definen las dependencias y la configuración del proyecto.
  • src/main.rs: Archivo principal del proyecto donde se escribe el código Rust.

  1. Estructura del Proyecto

2.1. Cargo.toml

El archivo Cargo.toml es crucial para la gestión de dependencias y la configuración del proyecto. Aquí hay un ejemplo básico de cómo se ve:

[package]
name = "my_project"
version = "0.1.0"
authors = ["Tu Nombre <[email protected]>"]
edition = "2018"

[dependencies]
  • [package]: Define la información básica del paquete.
  • [dependencies]: Lista de dependencias del proyecto.

2.2. src/main.rs

El archivo src/main.rs es el punto de entrada de tu aplicación. Aquí es donde escribirás tu función main.

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

  1. Gestión de Dependencias

3.1. Añadir Dependencias

Para añadir una dependencia, simplemente agrégala a la sección [dependencies] en Cargo.toml. Por ejemplo, para añadir la biblioteca rand:

[dependencies]
rand = "0.8"

Luego, puedes usar la biblioteca en tu código:

use rand::Rng;

fn main() {
    let mut rng = rand::thread_rng();
    let n: u32 = rng.gen_range(0..10);
    println!("Random number: {}", n);
}

3.2. Actualizar Dependencias

Para actualizar las dependencias a sus últimas versiones compatibles, usa el comando:

cargo update

  1. Compilación y Ejecución

4.1. Compilar el Proyecto

Para compilar tu proyecto, usa el comando:

cargo build

Esto generará un ejecutable en el directorio target/debug.

4.2. Ejecutar el Proyecto

Para ejecutar tu proyecto, usa el comando:

cargo run

Esto compilará y ejecutará tu proyecto en un solo paso.

4.3. Compilación para Producción

Para compilar tu proyecto en modo de producción, usa el comando:

cargo build --release

Esto generará un ejecutable optimizado en el directorio target/release.

  1. Organización del Código

5.1. Módulos

Rust permite organizar el código en módulos. Puedes crear nuevos archivos en el directorio src y declararlos como módulos en main.rs.

mod my_module;

fn main() {
    my_module::hello();
}

En src/my_module.rs:

pub fn hello() {
    println!("Hello from my_module!");
}

5.2. Submódulos

Puedes organizar aún más tu código utilizando submódulos. Por ejemplo, puedes tener un submódulo dentro de my_module.

En src/my_module/mod.rs:

pub mod sub_module;

pub fn hello() {
    println!("Hello from my_module!");
}

En src/my_module/sub_module.rs:

pub fn greet() {
    println!("Hello from sub_module!");
}

Y en main.rs:

mod my_module;

fn main() {
    my_module::hello();
    my_module::sub_module::greet();
}

  1. Ejercicio Práctico

Ejercicio

  1. Crea un nuevo proyecto llamado calculator.
  2. Añade una dependencia a la biblioteca num.
  3. Crea un módulo llamado operations con una función add que sume dos números.
  4. Usa la función add en main.rs para sumar dos números y mostrar el resultado.

Solución

  1. Crear el proyecto:
cargo new calculator
cd calculator
  1. Añadir la dependencia en Cargo.toml:
[dependencies]
num = "0.4"
  1. Crear el módulo operations:

En src/operations.rs:

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

En src/main.rs:

mod operations;

fn main() {
    let result = operations::add(5, 3);
    println!("The result is: {}", result);
}
  1. Ejecutar el proyecto:
cargo run

Conclusión

En este módulo, hemos aprendido cómo crear y estructurar un proyecto en Rust, gestionar dependencias y compilar el proyecto. También hemos visto cómo organizar el código en módulos para mantenerlo limpio y manejable. Con estos conocimientos, estás listo para construir proyectos más complejos y profesionales en Rust. ¡Adelante y sigue practicando!

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados