16 Ejemplos de Código de Programación en Rust

Rust es un lenguaje de programación de sistemas que ha ganado mucha popularidad en los últimos años por su eficiencia y seguridad. Combina la eficiencia de un lenguaje de bajo nivel como C++ con la seguridad que brinda la recolección de basura y la verificación de tipos.

En este artículo, repasaremos 16 ejemplos de código en Rust para ayudarte a entender mejor cómo funciona el lenguaje y cómo puedes utilizarlo en tus propios proyectos.

📋 Aquí podrás encontrar✍

1. Variables
2. Tipo de datos estructurados
3. Arreglos
4. Tuplas
5. Estructuras de control de flujo
6. Funciones
7. Métodos
8. Cierres
9. Enumeraciones
10. Manejo de errores
11. Lectura y escritura de archivos
12. Sockets de red
13. Hilos
14. Interfaz gráfica de usuario
15. Serialización y deserialización de datos
16. Pruebas unitarias

1. Variables

En Rust, las variables son inmutables de forma predeterminada, lo que significa que no se pueden cambiar una vez que se han asignado. Para crear una variable mutable, se debe utilizar la palabra clave "mut".

fn main() { let x = 5; let mut y = 6; y = y + x; println!("El valor de x es {} y el valor de y es {}", x, y); }

Como resultado, el programa imprimirá: "El valor de x es 5 y el valor de y es 11".

2. Tipo de datos estructurados

Rust permite crear tus propios tipos de datos estructurados. Para crear una estructura, se debe utilizar la palabra clave "struct".

struct Persona { nombre: String, edad: i32, }

fn main() { let persona = Persona { nombre: String::from("Juan"), edad: 30 }; println!("La persona se llama {} y tiene {} años", persona.nombre, persona.edad); }

El programa imprimirá: "La persona se llama Juan y tiene 30 años".

3. Arreglos

En Rust, los arreglos tienen un tamaño fijo y se definen con corchetes "[ ]".

fn main() { let numeros = [1, 2, 3, 4, 5]; println!("El segundo número en el arreglo es {}", numeros[1]); }

El programa imprimirá: "El segundo número en el arreglo es 2".

4. Tuplas

Las tuplas en Rust son un conjunto de valores separados por comas y se definen con paréntesis "( )".

fn main() { let tupla = (3, "Hola", 2.0); let (a, b, c) = tupla; println!("El valor de 'b' en la tupla es {}", b); }

El programa imprimirá: "El valor de 'b' en la tupla es Hola".

5. Estructuras de control de flujo

Rust admite las estructuras de control de flujo comunes como "if", "for" y "while".

fn main() { let numero = 7; if numero < 5 { println!("El número es menor a 5"); } else if numero == 5 { println!("El número es igual a 5"); } else { println!("El número es mayor a 5"); } }

El programa imprimirá: "El número es mayor a 5".

6. Funciones

Las funciones en Rust se definen con la palabra clave "fn" y pueden tener parámetros y valores de retorno.

fn suma(x: i32, y: i32) -> i32 { x + y }

fn main() { let resultado = suma(5, 10); println!("El resultado de la suma es {}", resultado); }

El programa imprimirá: "El resultado de la suma es 15".

7. Métodos

Los métodos son funciones que están asociadas a una estructura específica en Rust.

struct Punto { x: i32, y: i32, }


impl Punto {

    fn mover(&mut self, dx: i32, dy: i32) {

        self.x += dx;

        self.y += dy;

    }

}

fn main() { let mut punto = Punto { x: 0, y: 0 }; punto.mover(5, 10); println!("Las coordenadas del punto son ({}, {})", punto.x, punto.y); }

El programa imprimirá: "Las coordenadas del punto son (5, 10)".

8. Cierres

Los cierres en Rust son funciones anónimas que se pueden almacenar y pasar como parámetros.

fn sumar(a: i32, b: i32, f: F) -> i32 where F: Fn(i32, i32) -> i32 { f(a, b) }

fn main() { let resultado = sumar(5, 10, |x, y| x + y); println!("El resultado de la suma es {}", resultado); }

El programa imprimirá: "El resultado de la suma es 15".

9. Enumeraciones

Las enumeraciones en Rust se definen con la palabra clave "enum" y se utilizan para definir un conjunto de valores posibles.

enum Color { Rojo, Verde, Azul, }

fn main() { let color = Color::Verde; match color { Color::Rojo => println!("El color es Rojo"), Color::Verde => println!("El color es Verde"), Color::Azul => println!("El color es Azul"), } }

El programa imprimirá: "El color es Verde".

10. Manejo de errores

Rust tiene un sistema de manejo de errores muy robusto con la palabra clave "Result" que se utiliza para devolver un valor o un error.

fn dividir(a: i32, b: i32) -> Result { if b == 0 { Err(String::from("No se puede dividir entre 0")) } else { Ok(a / b) } }

fn main() { let resultado = dividir(10, 2); match resultado { Ok(valor) => println!("El resultado de la división es {}", valor), Err(mensaje) => println!("{}", mensaje), } }

El programa imprimirá: "El resultado de la división es 5".

11. Lectura y escritura de archivos

Rust tiene una API de manejo de archivos que permite leer y escribir archivos.

use std::fs::File; use std::io::prelude::*;


fn main() {

    let mut archivo = File::create("ejemplo.txt")

        .expect("Error al crear el archivo");
    archivo.write_all(b"Hola, mundo!")

        .expect("Error al escribir en el archivo");
    let mut contenido = String::new();

    File::open("ejemplo.txt")

        .expect("Error al abrir el archivo")

        .read_to_string(&mut contenido)

        .expect("Error al leer el archivo");

println!("El contenido del archivo es {}", contenido); }

El programa imprimirá: "El contenido del archivo es Hola, mundo!".

12. Sockets de red

Rust tiene una biblioteca de sockets de red para crear servidores y clientes.

use std::io::prelude::*; use std::net::{TcpListener, TcpStream};


fn manejar_conexion(mut stream: TcpStream) {

    let mut buffer = [0; 512];

    stream.read(&mut buffer).unwrap();

    println!("Recibido: {}", String::from_utf8_lossy(&buffer[..]));

}
fn main() {

    let listener = TcpListener::bind("127.0.0.1:8080").unwrap();

for stream in listener.incoming() { match stream { Ok(stream) => { println!("Conexión aceptada"); manejar_conexion(stream); } Err(e) => { println!("Error: {}", e); } } } }

Este código crea un servidor TCP que escucha en el puerto 8080 y maneja las conexiones entrantes.

13. Hilos

Rust tiene un modelo de programación de concurrencia seguro que aprovecha los hilos.

use std::thread; use std::time::Duration;


fn main() {

    let manejar = thread::spawn(|| {

        for i in 1..10 {

            println!("Manejando el hilo {}", i);

            thread::sleep(Duration::from_millis(1));

        }

    });
    for i in 1..5 {

        println!("Haciendo algo en el hilo principal {}", i);

        thread::sleep(Duration::from_millis(1));

    }

manejar.join().unwrap(); }

Este código ejecuta dos hilos, uno en el hilo principal que imprime una serie de mensajes y otro a través del hilo creado.

14. Interfaz gráfica de usuario

Para crear una interfaz gráfica de usuario, se puede utilizar la biblioteca webview-rs en Rust.

use web_view::*;

fn main() { web_view::builder() .title("Ejemplo de interfaz gráfica de usuario") .content(Content::Url("https://www.google.com")) .size(800, 600) .resizable(true) .debug(true) .user_data(()) .invoke_handler(|webview, arg| { match arg { "salir" => { webview.terminate(); } _ => {} } Ok(()) }) .run() .unwrap(); }

Este código crea una ventana de navegador que apunta a Google y tiene un botón de "salir" que cierra la ventana.

15. Serialización y deserialización de datos

Rust tiene una biblioteca de serialización y deserialización de datos que permite convertir datos de una forma a otra.

use serde::{Serialize, Deserialize}; use std::fs;


#[derive(Serialize, Deserialize)]

struct Persona {

    nombre: String,

    edad: i32,

}
fn main() {

    let persona = Persona { nombre: String::from("Juan"), edad: 30 };

    let persona_serializada = serde_json::to_string(&persona).unwrap();

    println!("La persona serializada es {}", persona_serializada);
    fs::write("datos.json", &persona_serializada).unwrap();

let datos_almacenados = fs::read_to_string("datos.json").unwrap(); let persona_deserializada: Persona = serde_json::from_str(&datos_almacenados).unwrap(); println!("El nombre de la persona es {} y su edad es {}", persona_deserializada.nombre, persona_deserializada.edad); }

Este código serializa una estructura de Persona y luego la almacena en un archivo llamado "datos.json". Luego, lee los datos del archivo y los deserializa en otra estructura de Persona.