Bij het ontwikkelen van een programma in Rust voor het verwerken van tekstbestanden, zoals CSV-bestanden, is een cruciaal aspect het effectief beheren van commandoregelargumenten. Dit kan op een efficiënte manier worden bereikt door gebruik te maken van de Clap-bibliotheek. In deze sectie wordt beschreven hoe je een programma kunt bouwen dat invoer accepteert via argumenten zoals bestanden, delimiters (scheidingstekens), en velden, bytes of tekens, met de nadruk op het correct implementeren en valideren van deze argumenten.

In de eerste stap moet je de benodigde crates toevoegen aan je Cargo.toml-bestand. De crates die je voor dit project nodig hebt zijn anyhow, clap, csv, regex, en een aantal dev-dependencies voor testdoeleinden:

toml
[dependencies]
anyhow = "1.0.79"
clap = { version = "4.5.0", features = ["derive"] }
csv = "1.3.0"
regex = "1.10.3"
[dev-dependencies]
assert_cmd = "2.0.13"
predicates = "3.0.4"
pretty_assertions = "1.4.0"
rand = "0.8.5"

De csv crate is essentieel voor het verwerken van gescheiden tekstbestanden, zoals CSV-bestanden. Je kunt het testen door cargo test uit te voeren, waarmee alle afhankelijkheden worden gedownload en de tests worden uitgevoerd (die eerst zullen mislukken, aangezien we de logica nog moeten implementeren).

Na het configureren van de benodigde crates, moeten we de verwachte invoer en het gebruik van het programma vastleggen. Het programma moet de volgende functionaliteit ondersteunen:

bash
$ cargo run -- --help
Rust versie van `cut`
Gebruik: cutr [OPTIES] <--fields |--bytes |--chars > [BESTANDEN]...
Argumenten:
   [BESTANDEN]...  Invoerbestand(en) [standaard: -]
Opties:
   -d, --delimiter   Veldscheidingsteken [standaard: "\t"]
   -f, --fields      Geselecteerde velden
   -b, --bytes       Geselecteerde bytes
   -c, --chars       Geselecteerde tekens
   -h, --help        Toon hulp
   -V, --version     Toon versie

In dit voorbeeld is het van belang dat één van de drie opties --fields, --bytes of --chars verplicht is, terwijl het bestand ([FILES]...) optioneel is, en standaard - (standaardinvoer) wordt gebruikt. Het scheidingsteken is standaard een tabblad. Als we de derive-benadering van Clap gebruiken, moeten we de structuren als volgt definiëren:

rust
#[derive(Debug)]
struct Args {
    files: Vec<String>,
    delimiter: String,
    extract: ArgsExtract,
}
#[derive(Debug)]
struct ArgsExtract {
    fields: Option<String>,
    bytes: Option<String>,
    chars: Option<String>,
}

De files parameter is een vector van strings die de naam van de bestanden bevat. Het delimiter is het scheidingsteken dat de velden in de tekstbestanden van elkaar scheidt, en extract verwijst naar een andere structuur die de argumenten voor velden, bytes of tekens bevat.

Na het definiëren van de structs kunnen we de argumenten gaan ophalen via de clap-bibliotheek. Hiervoor stellen we een get_args() functie op die de commandoregelargumenten verwerkt:

rust
fn get_args() -> Args {


    let matches = Command::new("cutr")


        .version("0.1.0")
        .author("Ken Youens-Clark")
        .about("Rust versie van `cut`")
        .get_matches();
    Args {
        files: ...,
        delimiter: ...,
        extract: ...,
    }
}

Het is essentieel dat de programma-argumenten goed worden weergegeven, bijvoorbeeld door de volgende main() functie te implementeren:

rust
fn main() {
    let args = get_args();
    println!("{:#?}", args);
}

Wanneer het programma zonder argumenten wordt uitgevoerd, moet het een foutmelding genereren. Dit komt doordat het verplicht is om een van de extract-opties (--fields, --bytes, of --chars) te gebruiken. Bij het opgeven van geldige argumenten, zoals:

bash
$ cargo run -- -f 1

Het programma zou een gestructureerde uitvoer moeten geven, bijvoorbeeld:

rust
Args {


    files: ["-"],
    delimiter: "\t",
    extract: ArgsExtract {
        fields: Some("1"),
        bytes: None,
        chars: None,
    },
}

De veldparameter (-f) wordt correct toegewezen aan de fields struct, terwijl de andere velden (bytes, chars) leeg blijven. Dit geldt ook voor andere argumenten, zoals -d voor het scheidingsteken en -b voor de bytes.

Daarnaast is het belangrijk dat de opties voor -f|--fields, -b|--bytes, en -c|--chars onderling exclusief zijn. Als je probeert om zowel -f als -b samen te gebruiken, zou het programma een foutmelding moeten geven:

bash
$ cargo run -- -f 1 -b 8-9 tests/inputs/movies1.tsv
error: de argumenten '--fields ' kunnen niet samen met '--bytes ' worden gebruikt
Gebruik: cutr <--fields |--bytes |--chars > [BESTANDEN]...

Wanneer de argumenten correct worden verwerkt, moeten ze worden gevalideerd, vooral in situaties waar een van de extract-opties vereist is. De implementatie van de validatie gebeurt in de run() functie.

Wanneer je ervoor kiest de builder-benadering van Clap te gebruiken, zou de get_args() functie er als volgt uit kunnen zien:

rust
fn get_args() -> Args {


    let matches = Command::new("cutr")
        .version("0.1.0")
        .author("Ken Youens-Clark")
        .about("Rust versie van `cut`")
        .arg(Arg::new("files")
            .value_name("FILES")
            .help("Invoerbestand(en)")
            .num_args(0..)
            .default_value("-"))
        .arg(Arg::new("delimiter")
            .value_name("DELIMITER")
            .short('d')
            .long("delim")
            .help("Veldscheidingsteken")
            .default_value("\t"))
        .arg(Arg::new("fields")
            .value_name("FIELDS")
            .short('f')
            .long("fields")
            .help("Geselecteerde velden"))
        .arg(Arg::new("bytes")
            .value_name("BYTES")
            .short('b')
            .long("bytes")
            .help("Geselecteerde bytes"))
        .arg(Arg::new("chars")
            .value_name("CHARS")
            .short('c')
            .long("chars")
            .help("Geselecteerde tekens"))
        .group(ArgGroup::new("extract")


            .args(["fields", "bytes", "chars"])


            .required(true)
            .multiple(false))
        .get_matches();
    Args {
        files: matches.get_many("files").unwrap().cloned().collect(),
        delimiter: matches.get_one("delimiter").cloned().unwrap(),
        extract: ArgsExtract {
            fields: matches.get_one("fields").cloned(),
            bytes: matches.get_one("bytes").cloned(),
            chars: matches.get_one("chars").cloned(),
        },
    }
}

Door gebruik te maken van de group annotatie, dwingen we de gebruiker om exact één van de --fields, --bytes, of --chars argumenten op te geven, wat essentieel is voor de juiste werking van het programma.

Hoe kies je het juiste Extract-type in een programma en hoe je karakters of bytes kunt extraheren

In de context van het werken met gegevensverwerking in Rust, is het essentieel om te begrijpen hoe je de juiste extractievariant kiest om gegevens uit bestanden te halen, zoals karakters, bytes of velden. Het programma begint met het identificeren van welk type extractie wordt uitgevoerd door te controleren op de aanwezigheid van specifieke argumenten zoals velden, bytes of karakters. Het verwerken van deze gegevens vereist een zorgvuldige benadering van het verwerken van tekst op basis van je gekozen extractievariant.

In een eenvoudig voorbeeld, waar een gebruiker niet de juiste selectie maakt, kan een foutmelding worden gegenereerd om de juiste extractieoptie af te dwingen. Het programma controleert dus of de argumenten voor velden, bytes of karakters aanwezig zijn en past de juiste extractievariant toe. Het implementeren van dit systeem vereist een grondig begrip van het omgaan met verschillende datatypen en een strategische manier van foutafhandeling. Wanneer geen van de opties is geselecteerd, zal de macro unreachable! een paniek veroorzaken, aangezien dit logischerwijs nooit zou moeten gebeuren.

Als het programma correct geconfigureerd is, kan het niet alleen de juiste extractievariant kiezen, maar ook de gegevens verwerken door middel van functies die specifiek zijn voor het extraheren van karakters of bytes. Dit wordt bijvoorbeeld gedaan door de functie extract_chars, die een nieuw string-object retourneert met de karakters die op bepaalde posities binnen een tekstregel staan. Hetzelfde principe wordt toegepast bij de functie extract_bytes, die gegevens op basis van byte-indexen verwerkt.

Een uitdaging bij het extraheren van karakters of bytes is het omgaan met multibyte-karakters zoals 'á'. Bij het selecteren van een enkel byte uit zo'n teken kan het resultaat een Unicode-vervangingskarakter (�) opleveren, wat betekent dat de multibyte-informatie wordt verbroken. Dit vraagt om een zorgvuldige afweging van de gekozen extractie en de beperkingen van de encodering van de tekst.

Voor het extraheren van tekst uit bestandsinhoud, is het ook van belang om de juiste functies te gebruiken om het bestand te openen en de inhoud in te lezen. Een handige benadering hiervoor is het gebruik van een functie zoals open, die het mogelijk maakt om te kiezen of je tekst wilt inleiden van een bestand of van de standaardinvoer. Het lezen van een bestand gebeurt via de BufReader, wat zorgt voor een efficiënte manier om grote hoeveelheden tekst te verwerken zonder te veel geheugen te verbruiken.

Wanneer je werkt met gegevens die uit bestanden komen, kunnen deze vaak een bepaald scheidingsteken bevatten, zoals een tab of een komma, die de verschillende velden binnen een record aanduidt. Dit komt veel voor in CSV-bestanden, waar velden vaak worden gescheiden door komma's. In sommige gevallen kan een scheidingsteken ook deel uitmaken van de gegevens zelf, bijvoorbeeld in titels zoals "20,000 Leagues Under the Sea", waarbij de komma binnen aanhalingstekens moet worden behandeld. Dit benadrukt het belang van het correct ontsnappen van scheidingstekens door het gebruik van geschikte bibliotheken zoals csv, die deze complexiteit voor ons kan afhandelen.

Wanneer we met CSV-bestanden werken, wordt de csv crate een handige tool. Het gebruik van ReaderBuilder maakt het mogelijk om gegevens op te halen die door een bepaald scheidingsteken zijn gescheiden. De functie csv::StringRecord helpt bij het beheren van deze records, zodat ze correct worden geanalyseerd en geformatteerd. Het programma maakt hierbij gebruik van een iterator over de records en stelt ons in staat om de velden van elk record te extraheren en naar wens te formatteren.

Het gebruik van de csv::ReaderBuilder is vooral handig wanneer je met gegevens werkt die in tabellen zijn georganiseerd, zoals CSV-bestanden. Bij het verwerken van deze gegevens moet je ook rekening houden met de mogelijkheid van geescaped scheidingstekens, zoals komma's in velden die tussen aanhalingstekens staan. Hierdoor is het noodzakelijk om de juiste escapes en de juiste methoden te gebruiken bij het uitlezen en schrijven van deze bestanden.

Het verwerken van delimited text files biedt meer complexiteit dan eenvoudig bestand lezen. Wanneer je werkt met bestandsformaten zoals CSV, is het van belang dat je de juiste methoden gebruikt om velden te extraheren, te verwerken en weer weg te schrijven, met aandacht voor speciale gevallen zoals het omgaan met aanhalingstekens of andere escapes die deel uitmaken van de gegevens.

De belangrijkste les voor de lezer is dat het werken met extracties niet alleen vereist dat je de juiste extractievariant kiest, maar ook dat je rekening houdt met de encoding en de complexiteit van de gebruikte scheidingstekens, zoals in CSV-bestanden. Het begrijpen van het verschil tussen karakters, bytes en velden, evenals het correct omgaan met encoding en escapes, is cruciaal voor het succesvol verwerken van tekstbestanden in Rust.

Hoe werkt de ls-opdracht in Unix-systemen en wat moet je weten over de implementatie van een eigen versie?

De ls-opdracht, een van de meest fundamentele commando’s in Unix-gebaseerde systemen, biedt een manier om de inhoud van mappen weer te geven. Bij het gebruik van ls worden de namen van bestanden en mappen getoond, met aanvullende informatie afhankelijk van de opties die zijn ingevoerd. De basisfunctie van de ls-opdracht is simpel: het toont de bestanden van een opgegeven pad of de huidige directory als er geen pad wordt opgegeven.

Wanneer je ls uitvoert zonder enige opties of argumenten, wordt de inhoud van de huidige directory getoond. Als je bijvoorbeeld het commando uitvoert in de map 14_lsr, zou het volgende resultaat verschijnen:

bash
$ cd 14_lsr
$ ls
Cargo.toml         set-test-perms.sh* src/               tests/

In de bovenstaande uitvoer worden de bestanden en mappen getoond die zich in de map 14_lsr

Wat zegt loyaliteit over ons leven en keuzes?
Hoe spieren en spiermassa veranderen met de leeftijd en wat dat betekent voor je gezondheid
Hoe de Waardepropositie de Basis is van een Bedrijfsmodel en de Invloed op Verdienmodellen