Getters

Parte de la sección Programación Orientada a Objetos del Journey de Rust de Coddy. Lección 11 de 61.

Con los campos privados, el código externo no puede acceder directamente a los datos de tu estructura. Pero a veces necesitas permitir que otros lean los datos sin darles la posibilidad de modificarlos. Aquí es donde entran en juego los métodos getter.

Un getter es simplemente un método público que devuelve una referencia a un campo privado:

// wallet.rs
pub struct Wallet {
    balance: f64,
}

impl Wallet {
    pub fn new(initial: f64) -> Wallet {
        Wallet { balance: initial }
    }
    
    pub fn balance(&self) -> f64 {
        self.balance
    }
}

El método balance() recibe &self (acceso de solo lectura) y devuelve el valor del campo privado. En Rust, los getters suelen llamarse igual que el campo: no se necesita el prefijo get_.

Ahora el código externo puede leer el saldo mediante el método:

// main.rs
mod wallet;
use wallet::Wallet;

fn main() {
    let w = Wallet::new(100.0);
    println!("Balance: {}", w.balance());  // ¡Funciona!
}

Para los campos que contienen datos poseídos, como String, a menudo devolverás una referencia para evitar copias innecesarias:

pub fn name(&self) -> &String {
    &self.name
}

Los getters te proporcionan acceso de lectura controlado mientras mantienen protegido el campo. La estructura sigue teniendo el control de sus datos: el código externo puede mirar, pero no puede tocar.

Desafío

Fácil

Construyamos un sistema de perfil de usuario que demuestre cómo los métodos getter proporcionan acceso de lectura controlado a los datos privados.

Crearás dos archivos para organizar tu código:

profile.rs: Define una estructura UserProfile con dos campos privados: username (String) y age (u32). La estructura en sí debe ser pública, pero los campos deben permanecer privados. Implementa un constructor público new que reciba un nombre de usuario y una edad. Después, añade dos métodos getter:
- username: devuelve una referencia al nombre de usuario (&String)
- age: devuelve el valor de la edad (u32)
main.rs: Incluye tu módulo de perfil, crea un UserProfile y usa los métodos getter para imprimir la información del usuario.

Recuerda que los getter en Rust normalmente llevan el mismo nombre que el campo: no se necesita el prefijo get_. Para los campos String, devuelve una referencia para evitar copias innecesarias.

Tu salida debe seguir este formato exacto:

Username: {username}
Age: {age}

Por ejemplo, si creas un perfil con el nombre de usuario "alice" y la edad 25, la salida sería:

Username: alice
Age: 25

Recibirás dos entradas: el nombre de usuario y la edad.

Pruébalo tú mismo

mod profile;

use profile::UserProfile;

fn main() {
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let username = input1.trim().to_string();

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let age: u32 = input2.trim().parse().expect("Failed to parse age");

    // TODO: Crea un UserProfile usando el constructor

    // TODO: Usa los métodos getter para imprimir el username y la age
    // Formato:
    // Username: {username}
    // Age: {age}
}