Hoe je een geavanceerde uitvoer van een programma in Rust kunt formatteren en testen

In de context van een programma dat regels, woorden en bytes afdrukt, kan het nodig zijn om de uitvoer te formatteren afhankelijk van bepaalde voorwaarden. Om dit te bereiken, wordt een functie zoals format_field vaak gebruikt. Deze functie accepteert een numerieke waarde (bijvoorbeeld het aantal regels) en een booleaanse waarde die bepaalt of deze waarde wel of niet moet worden weergegeven. De functie retourneert een geformatteerde string of een lege string, afhankelijk van de ingestelde voorwaarden.

Een voorbeeld van zo'n functie in Rust zou er als volgt uitzien:

rust
Copy code
fn format_field(value: usize, show: bool) -> String {

    if show {
        format!("{value:>8}")
    } else {
        "".to_string()
    }
}

Deze functie accepteert twee argumenten: een usize waarde en een bool waarde genaamd show. Als show waar is, wordt de numerieke waarde geformatteerd en als string met een breedte van acht tekens geretourneerd. Als show onwaar is, wordt een lege string geretourneerd. Het gebruik van String in plaats van str is noodzakelijk omdat de waarde dynamisch wordt gegenereerd tijdens de uitvoering, terwijl str een onveranderlijke en vaste lengte heeft.

Bij het schrijven van tests voor deze functie kan de module zoals hieronder worden uitgebreid:

rust
Copy code
#[cfg(test)] 
mod tests { 
    use super::{count, format_field, FileInfo}; 
    #[test] 
    fn test_count() {} // Zelfde als voorheen 
    #[test] 
    fn test_format_field() { 

        assert_eq!(format_field(1, false), ""); 

        assert_eq!(format_field(3, true), "       3"); 

        assert_eq!(format_field(10, true), "      10"); 

    } 
}

De test_format_field test controleert of de functie correct werkt wanneer show waar of onwaar is. Dit helpt om de functionaliteit van de formatteringslogica in verschillende scenario's te verifiëren.

In de praktijk wordt de functie format_field vaak gebruikt in de context van een groter programma waarin de uitvoer van verschillende bestandsstatistieken wordt geformatteerd. Stel je voor dat je een functie hebt die meerdere bestanden verwerkt en voor elk bestand informatie zoals het aantal regels, woorden, bytes en tekens afdrukt:

rust
Copy code
fn run(mut args: Args) -> Result<()> { 

    for filename in &args.files { 
        match open(filename) { 
            Err(err) => eprintln!("{filename}: {err}"), 
            Ok(file) => { 
                let info = count(file)?; 
                println!( 
                    "{}{}{}{}{}", 
                    format_field(info.num_lines, args.lines), 
                    format_field(info.num_words, args.words), 
                    format_field(info.num_bytes, args.bytes), 
                    format_field(info.num_chars, args.chars), 
                    if filename == "-" { 
                        "".to_string() 
                    } else { 
                        format!(" {filename}") 
                    } 
                ); 
            } 
        } 
    } 
    Ok(()) 
}

In dit geval zorgt de run functie ervoor dat de informatie over het bestand netjes wordt geformatteerd, waarbij de uitvoer wordt aangepast aan de ingevoerde argumenten (zoals de keuzemogelijkheden voor het weergeven van regels, woorden, bytes, en tekens). De functie format_field wordt gebruikt om ervoor te zorgen dat de verschillende statistieken op de juiste manier worden uitgelijnd. Als de bestandsnaam een streepje ("-") is, wordt de naam niet afgedrukt.

Daarnaast is het belangrijk om met meerdere bestanden te werken en een totaal van de statistieken voor alle bestanden bij te houden. Dit kan worden gedaan door tijdelijke variabelen te gebruiken voor de totale aantallen regels, woorden, bytes en tekens, die worden bijgewerkt na het verwerken van elk bestand. De uiteindelijke som wordt dan afgedrukt als er meer dan één bestand wordt verwerkt:

rust
Copy code
fn run(mut args: Args) -> Result<()> { 

    let mut total_lines = 0; 
    let mut total_words = 0; 
    let mut total_bytes = 0; 
    let mut total_chars = 0; 
    for filename in &args.files { 
        match open(filename) { 
            Err(err) => eprintln!("{filename}: {err}"), 
            Ok(file) => { 
                let info = count(file)?; 
                println!( 
                    "{}{}{}{}{}", 
                    format_field(info.num_lines, args.lines), 
                    format_field(info.num_words, args.words), 
                    format_field(info.num_bytes, args.bytes), 
                    format_field(info.num_chars, args.chars), 
                    if filename.as_str() == "-" { 
                        "".to_string() 
                    } else { 
                        format!(" {}", filename) 
                    } 
                ); 
                total_lines += info.num_lines; 
                total_words += info.num_words; 
                total_bytes += info.num_bytes; 
                total_chars += info.num_chars; 
            } 
        } 
    } 
    if args.files.len() > 1 { 
        println!( 
            "{}{}{}{} total", 
            format_field(total_lines, args.lines), 
            format_field(total_words, args.words), 
            format_field(total_bytes, args.bytes), 
            format_field(total_chars, args.chars) 
        ); 
    } 
    Ok(()) 
}

Hiermee wordt ervoor gezorgd dat de totaalwaarden voor alle statistieken correct worden bijgehouden en afgedrukt aan het einde van de uitvoering, mits er meer dan één bestand wordt verwerkt. Dit is belangrijk voor gebruikers die met meerdere bestanden werken en een overzicht willen van de totale statistieken.

De benadering in deze tekst kan verder worden uitgebreid door bijvoorbeeld ondersteuning toe te voegen voor extra opties, zoals het lezen van bestandsnamen uit een bestand of het tonen van de lengte van de langste regel. Het aanpassen van de uitvoer om deze overeen te laten komen met de GNU- of BSD-versies van wc is een nuttige oefening in compatibiliteit en zou de bruikbaarheid van het programma verder kunnen vergroten.

Verder kan men bij het werken met internationale tekens en complexe bestandsindelingen, zoals Japanse karakters, tegen uitdagingen aanlopen. Het testen van de programma-uitvoer met verschillende tekencoderingen kan een nuttige uitbreiding zijn. Bijvoorbeeld, de manier waarop de verschillende versies van wc omgaan met Japanse karakters kan interessante afwijkingen vertonen, die de gebruiker zou moeten begrijpen om volledige compatibiliteit te garanderen.

Hoe Organiseer en Test je een Rust Programma?

In de wereld van de softwareontwikkeling zijn de eerste stappen vaak de belangrijkste. Bij het leren van een nieuwe programmeertaal, zoals Rust, is het gebruikelijk om te beginnen met een eenvoudig "Hello, World!"-programma. Dit helpt je niet alleen de basisprincipes van de taal te begrijpen, maar ook hoe je een project organiseert en test. In dit hoofdstuk wordt besproken hoe je een eenvoudige Rust-code kunt compileren, een project kunt opzetten, externe crates kunt gebruiken en hoe je programma’s kunt testen.

Om te beginnen, maak je een eenvoudige Rust broncode. Dit doe je door een bestand genaamd hello.rs te maken en de volgende code in een teksteditor te typen:

rust
Copy code
fn main() {

    println!("Hello, world!");
}

Deze code maakt gebruik van een functie genaamd main, wat de standaard instappunt is voor een Rust-programma. De macro println! wordt gebruikt om de tekst "Hello, world!" naar de standaarduitvoer (STDOUT) te sturen. Merk op dat Rust macros zoals println! een uitroepteken bevatten, wat hen onderscheidt van reguliere functies.

Na het schrijven van de code, moet je de rustc compiler gebruiken om de broncode te compileren:

bash
Copy code
$ rustc hello.rs

Dit zal een uitvoerbaar bestand genaamd hello (op macOS en Linux) of hello.exe (op Windows) genereren. Dit bestand kan nu direct worden uitgevoerd om het programma te draaien:

bash
Copy code
$ ./hello
Hello, world!

De stappen om een projectstructuur in te stellen zouden als volgt kunnen zijn:

1. Verwijder de gegenereerde uitvoerbare bestanden om ruimte te maken voor de nieuwe mappenstructuur.

2. Maak een nieuwe map en submappen voor je broncodebestanden.

Op een Unix-systeem kun je het volgende doen:

bash
Copy code
$ rm hello
$ mkdir -p hello/src
$ mv hello.rs hello/src

Wanneer je nu de broncode opnieuw compileert:

bash
Copy code
$ cd hello

$ rustc src/hello.rs

Het is essentieel om te begrijpen dat het organiseren van een project in een duidelijke mapstructuur, zelfs voor kleine programma’s, bijdraagt aan de leesbaarheid en onderhoudbaarheid van de code. Een ongestructureerd project kan snel chaotisch worden naarmate het groeit.

Cargo, de officiële pakketbeheerder en buildtool voor Rust, biedt een eenvoudigere manier om een nieuw project op te zetten. In plaats van handmatig mappen en bestanden te maken, kun je eenvoudig het volgende commando uitvoeren:

bash
Copy code
$ cargo new hello

Dit maakt automatisch de juiste mapstructuur aan met een configuratiebestand genaamd Cargo.toml en een standaard src/main.rs bestand. Je kunt vervolgens eenvoudig de code compileren en uitvoeren met:

bash
Copy code
$ cargo run

Cargo maakt het mogelijk om alle afhankelijkheden van je project op een eenvoudige manier te beheren. Door gebruik te maken van externe crates van crates.io, de officiële Rust package registry, kun je snel krachtige functionaliteit aan je project toevoegen. Het is belangrijk om te begrijpen dat afhankelijkheden en externe crates goed beheerd moeten worden om problemen in je project te voorkomen, zoals versieconflicten of onbetrouwbare code.

Bij het ontwikkelen van Rust-programma’s komt testen vaak op de voorgrond. Het schrijven van testen voor je programma is essentieel om de kwaliteit van je code te waarborgen. In Rust kun je testen organiseren in een speciale map genaamd tests, die wordt aangeroepen door het commando cargo test. Dit helpt niet alleen bij het vinden van bugs, maar biedt ook een solide basis voor het verder uitbreiden van de functionaliteit van je project.

Het gebruik van de juiste best practices voor projectorganisatie, codebeheer en testen is cruciaal voor het succes van elke ontwikkelingsinspanning. Het maakt het proces niet alleen efficiënter, maar zorgt er ook voor dat je programma’s betrouwbaar en schaalbaar blijven, zelfs naarmate je ze verder uitbreidt met meer complexe functionaliteit.

Endtext