Dlaczego warto poznać Rust? Korzyści z pisania narzędzi wiersza poleceń

Rust to język, który stał się jednym z najgorętszych tematów w świecie programowania. Choć na pierwszy rzut oka może wydawać się trudny do opanowania, jego możliwości w zakresie wydajności i bezpieczeństwa przyciągają coraz więcej programistów. W szczególności, dzięki takim cechom jak gwarancje bezpieczeństwa pamięci i wyjątkowa wydajność, Rust stał się wyborem wielu firm do budowy oprogramowania systemowego, narzędzi wiersza poleceń i wielu innych aplikacji, gdzie niezawodność jest kluczowa. Jednak jak każda nowa technologia, wymaga czasu i praktyki, by w pełni zrozumieć i wykorzystać jej potencjał.

W tej książce skoncentrujemy się na nauce Rusta przez tworzenie prostych, ale niezwykle użytecznych narzędzi wiersza poleceń. Dlaczego wiersz poleceń? Otóż, pisanie takich programów daje nie tylko solidne podstawy językowe, ale i pomaga zrozumieć kluczowe koncepcje programowania, które mogą przydać się w każdym innym projekcie. Narzędzia takie jak head, cal czy ls to klasyki systemu Unix, które posiadają swoją specyfikę i wymuszają zastosowanie efektywnych rozwiązań.

Rust ma jedną wielką zaletę, której nie da się zignorować: pamięć. W językach takich jak C++ czy Java programista ma pełną kontrolę nad pamięcią, co bywa zarówno błogosławieństwem, jak i przekleństwem. Rust natomiast wprowadza system zarządzania pamięcią bez konieczności korzystania z garbage collectora, co daje nie tylko bezpieczeństwo, ale i wydajność porównywalną z językami niskopoziomowymi. To dzięki systemowi borrow checkera, który sprawdza, która część programu ma dostęp do danych w danym momencie, unikamy problemów z dostępem do nieprawidłowej pamięci, takich jak tzw. "race conditions".

Zrozumienie, jak działają takie elementy jak wskaźniki, mutowalne zmienne i prawa dostępu do danych, jest niezbędne, aby pisać efektywne programy w Rust. Dzięki temu, że Rust jest językiem statycznie typowanym, każda zmienna ma jasno określony typ, co zmniejsza ryzyko błędów związanych z niewłaściwym traktowaniem danych. Choć początkowo może to wydawać się ograniczeniem, w rzeczywistości pomaga to w szybkim wykrywaniu błędów jeszcze na etapie kompilacji, a nie dopiero podczas uruchamiania programu.

Jednym z najważniejszych aspektów Rust, który odróżnia go od innych języków, jest jego podejście do równoległości i bezpieczeństwa wątków. W przeciwieństwie do wielu innych języków, Rust zapewnia, że nie wystąpią problemy związane z dostępem do tych samych zasobów w różnych wątkach, chyba że programista wyraźnie o to poprosi. Daje to ogromną moc i pewność, że nasz program będzie działał stabilnie, nawet w złożonych środowiskach równoległych.

Pisząc programy wiersza poleceń w Rust, nauczysz się również obsługiwać argumenty linii poleceń, co jest kluczową umiejętnością przy tworzeniu narzędzi i aplikacji. Dzięki temu zrozumiesz, jak działa komunikacja między użytkownikiem a programem, jak przekazywać dane wejściowe i jak odpowiednio kierować dane wyjściowe lub błędy do różnych strumieni. Nauczysz się, jak używać funkcji takich jak stdin, stdout i stderr, co jest podstawą wielu narzędzi w systemach uniksowych.

Ponadto, Rust zachęca do korzystania z funkcji wyższego rzędu, które pozwalają na bardziej elastyczne i czyste zarządzanie kodem. Przyjdzie Ci także zmierzyć się z typami enumeracyjnymi i sumami, które pozwalają na bardziej zorganizowane i bezpieczne zarządzanie różnymi stanami w programie. To podejście minimalizuje ryzyko błędów związanych z pominięciem jakiegoś możliwego stanu w kodzie, co w rezultacie prowadzi do bardziej niezawodnych aplikacji.

Jeśli nie znasz jeszcze Uniksa ani podstaw programowania wiersza poleceń, nie martw się – pisząc programy w Rust, zrozumiesz, jak bardzo ten sposób interakcji z systemem może być potężny. Nauczysz się korzystać z potężnych narzędzi do manipulacji plikami, przetwarzania tekstu, czy obsługi błędów, które są fundamentem wielu nowoczesnych aplikacji. Na przestrzeni tej książki stworzysz proste, ale bardzo użyteczne programy, które pokazują, jak w Rust realizować te klasyczne operacje, takie jak manipulacja plikami, walidacja parametrów wejściowych, czy obsługa błędów.

Podczas pisania tych narzędzi warto zastanowić się, jak każde z tych rozwiązań można by wykorzystać w bardziej złożonych projektach. To, co wydaje się prostą funkcjonalnością, może być fundamentem potężnych aplikacji. Rust daje Ci narzędzia do tworzenia bezpiecznego, wydajnego kodu, który nie boi się pracy w trudnych, często narażonych na błędy warunkach.

Jak zbudować program do przetwarzania argumentów w Rust?

W Rust, przetwarzanie argumentów wiersza poleceń jest niezbędną częścią wielu aplikacji. W tym przypadku omówimy, jak za pomocą biblioteki clap stworzyć program, który będzie działał podobnie do narzędzia cat, umożliwiając użytkownikowi kontrolowanie wyświetlania numerów linii w plikach tekstowych. Program ten, poza standardowym przetwarzaniem plików, będzie obsługiwał opcje, takie jak numerowanie linii czy numerowanie tylko linii, które nie są puste. Wspomniane opcje są kluczowe w kontekście użytkowania narzędzi linii poleceń w systemach uniksowych, gdzie różne narzędzia tekstowe wspierają takie funkcje.

Pierwszym krokiem jest stworzenie struktury Args, która będzie przechowywać informacje o przekazanych argumentach. W tej strukturze będziemy trzymać następujące dane:

• files: Wektor przechowujący ścieżki do plików, które mają zostać przetworzone.

• number_lines: Flaga Boolean, która wskazuje, czy program ma numerować wszystkie linie.

• number_nonblank_lines: Flaga Boolean, która wskazuje, czy numerować tylko te linie, które nie są puste.

Kolejnym krokiem jest zdefiniowanie funkcji get_args, która odpowiedzialna będzie za parsowanie argumentów przekazanych w linii poleceń. Funkcja ta korzysta z biblioteki clap, by zdefiniować dostępne opcje i ich zachowanie. Możemy zdefiniować argumenty za pomocą następujących opcji:

• -n lub --number: Numery linii, jeśli ta opcja jest włączona.

• -b lub --number-nonblank: Numerowanie tylko linii niebiałych.

• -h lub --help: Wyświetlenie pomocy dotyczącej użycia programu.

• -V lub --version: Wyświetlenie wersji programu.

Domyślnie program będzie traktować znak "-" jako reprezentację wejścia ze standardowego wejścia (STDIN). Ponadto, oba argumenty numeryczne (number_lines i number_nonblank_lines) będą domyślnie ustawione na false.

Po poprawnym przetworzeniu argumentów, program powinien umożliwić numerowanie linii w plikach. Jeśli użytkownik zdecyduje się włączyć opcję -n, program będzie numerować wszystkie linie w pliku. Z kolei opcja -b powoduje numerowanie tylko tych linii, które zawierają jakieś dane. Istotnym aspektem jest także kwestia wzajemnej wykluczności opcji -n i -b. Zgodnie z wymaganiami, te dwie opcje nie mogą być używane jednocześnie. Gdy użytkownik spróbuje włączyć obie opcje, program powinien zgłosić błąd.

Po przetworzeniu argumentów, kolejnym krokiem jest zaimplementowanie funkcji run, która będzie odpowiedzialna za przetwarzanie plików na podstawie przekazanych opcji. Funkcja ta iteruje przez pliki z argumentu files, a następnie wyświetla zawartość każdego z nich, zgodnie z wybranymi opcjami. Funkcja ta może korzystać z innych funkcji pomocniczych, które zajmują się wczytywaniem plików, numerowaniem linii i drukowaniem wyników na ekranie. Ponadto, jest to dobra okazja do oddzielenia logiki parsowania argumentów od samego przetwarzania danych, co ułatwia modyfikowanie programu w przyszłości.

Kiedy użytkownik uruchamia program, może przekazać pliki jako argumenty wiersza poleceń, a program powinien prawidłowo je obsługiwać. Na przykład, kiedy użytkownik poda pliki tests/inputs/*.txt, program powinien przetworzyć wszystkie pliki tekstowe w tym katalogu, wyświetlając je z odpowiednim numerowaniem linii, jeśli to wymagane.

W przypadku wystąpienia błędów w czasie działania programu, warto odpowiednio obsługiwać błędy za pomocą typu Result, aby uniknąć nieoczekiwanych awarii aplikacji. Błędy mogą wynikać np. z problemów z dostępem do plików, błędnych argumentów w linii poleceń czy innych nieprzewidzianych sytuacji. Użycie operatora ? w funkcjach może automatycznie przekazywać błędy do wywołującej funkcji, co pozwala na ich dalszą obsługę.

Przy tworzeniu programu w stylu Rust, szczególną uwagę należy zwrócić na zarządzanie pamięcią i bezpieczeństwo wątków. Dzięki systemowi typów, Rust zmusza nas do rozważenia wszystkich możliwych sytuacji związanych z dostępem do danych. To zapewnia, że nasza aplikacja będzie niezawodna i odporna na typowe błędy związane z zarządzaniem pamięcią, które mogą występować w innych językach.

Jak zbudować aplikację w Rust dla narzędzia uniq

Tworzenie narzędzia opartego na funkcji uniq, które filtruje powtarzające się linie w pliku wejściowym, jest doskonałym ćwiczeniem w nauce programowania w języku Rust. Przykład ten pokazuje, jak zaimplementować wersję uniq w tym języku, a także jakie opcje dostosowywania mogą być przydatne w codziennej pracy programisty.

W systemie Unix komenda uniq służy do usuwania zduplikowanych linii w pliku, pozostawiając tylko pierwszą z nich. Kluczowe dla tej komendy jest to, że identyfikuje tylko sąsiadujące powtarzające się linie, dlatego przed jej użyciem często stosuje się komendę sort, aby posortować dane i zapewnić, że zduplikowane linie będą obok siebie. Narzędzie uniq w wersji GNU oraz BSD oferuje różne dodatkowe opcje, ale ich główna funkcja pozostaje niezmienna – filtracja zduplikowanych linii.

Wykorzystanie Crate'ów i Struktur

Pierwszym krokiem w implementacji programu w Rust jest zdefiniowanie odpowiednich zależności w pliku Cargo.toml. Będziemy potrzebować crate'ów takich jak clap do obsługi argumentów wiersza poleceń, anyhow do obsługi błędów, oraz tempfile do tworzenia tymczasowych plików w trakcie testowania. Kod konfiguracji zależności wygląda następująco:

toml
Copy code
[dependencies]

anyhow = "1.0.79"
clap = { version = "4.5.0", features = ["derive"] }
[dev-dependencies]
assert_cmd = "2.0.13"
predicates = "3.0.4"
pretty_assertions = "1.4.0"
tempfile = "3.10.0"
rand = "0.8.5"

Po skonfigurowaniu zależności możemy przejść do implementacji struktury, która będzie przechowywać informacje o argumentach przekazywanych do programu, takich jak nazwa pliku wejściowego, plik wyjściowy oraz flaga do liczenia wystąpień.

rust
Copy code
#[derive(Debug)]
struct Args {
    in_file: String,
    out_file: Option<String>,
    count: bool,
}

Parsowanie Argumentów

Implementacja funkcji get_args może wyglądać następująco:

rust
Copy code
fn get_args() -> Args {

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

        .version("0.1.0")
        .author("Ken Youens-Clark")
        .about("Rust version of `uniq`")
        .arg(Arg::new("in_file")
            .value_name("IN_FILE")
            .help("Input file")
            .default_value("-"))
        .arg(Arg::new("out_file")
            .value_name("OUT_FILE")
            .help("Output file"))
        .arg(Arg::new("count")
            .short('c')
            .long("count")
            .action(ArgAction::SetTrue)
            .help("Show counts"))
        .get_matches();
    Args {
        in_file: matches.get_one("in_file").cloned().unwrap(),
        out_file: matches.get_one("out_file").cloned(),
        count: matches.get_flag("count"),
    }
}

Testowanie Programu

Testy powinny obejmować różne przypadki użycia:

1. Plik wejściowy jako jedyny argument.

2. Plik wejściowy z włączoną opcją --count.

3. Wejście ze standardowego wejścia bez argumentów.

4. Wejście ze standardowego wejścia z włączoną opcją --count.

5. Plik wejściowy i wyjściowy jako argumenty.

6. Plik wejściowy i wyjściowy z włączoną opcją --count.

Kiedy zaczynamy pisać testy, warto zwrócić uwagę na strukturę katalogów testowych. Testy w projekcie mogą być zapisane w katalogu tests, a ich głównym celem jest zapewnienie poprawności działania programu w różnych scenariuszach.

Istotne Zagadnienia

Warto pamiętać, że choć narzędzie uniq w Rust jest potężnym rozwiązaniem, zawsze należy mieć na uwadze, że prawdziwa moc tej komendy objawia się dopiero w połączeniu z innymi narzędziami systemowymi. W szczególności, jeżeli zależy nam na dokładniejszym analizowaniu duplikatów, warto rozważyć wstępne posortowanie pliku wejściowego lub użycie opcji sort -u, które pozwala na usunięcie duplikatów jeszcze przed użyciem uniq.

Innym ważnym aspektem jest prawidłowe zarządzanie danymi wejściowymi. W przypadku pracy z dużymi plikami tekstowymi warto pomyśleć o optymalizacji odczytu danych i ich przetwarzania, szczególnie jeśli pracujemy z plikami o dużych rozmiarach.

Jak poprawnie przetwarzać dane wejściowe przy użyciu wyrażeń regularnych w Rust?

Aby skutecznie przetwarzać dane wejściowe w języku Rust, często konieczne jest wykorzystanie narzędzi do walidacji i parsowania danych, takich jak wyrażenia regularne czy wbudowane metody konwersji typów. W tej sekcji omówimy, jak za pomocą wyrażenia regularnego można poprawnie analizować argumenty wejściowe w postaci liczb, z uwzględnieniem znaków plusa i minusa, a także przedstawimy alternatywne podejście bazujące na wbudowanych funkcjach języka Rust.

Rozpocznijmy od funkcji parse_num, która służy do przetwarzania wartości numerycznych przekazywanych w postaci łańcuchów tekstowych. Na początek, warto zastosować wyrażenie regularne, które będzie dopasowywało liczby całkowite z opcjonalnym znakiem plusa lub minusa. Funkcja parse_num wykorzystuje wyrażenie regularne, które dopasowuje ciągi liczbowe z opcjonalnym prefiksem "+" lub "-":

rust
Copy code
fn parse_num(val: String) -> Result<TakeNum, Error> {

    let num_re = Regex::new(r"^([+-])?(\d+)$").unwrap();
    match num_re.captures(&val) {
        Some(caps) => {
            let sign = caps.get(1).map_or("-", |m| m.as_str());
            let signed_num = format!("{sign}{}", caps.get(2).unwrap().as_str());

            if let Ok(num) = signed_num.parse() {

                if sign == "+" && num == 0 {
                    Ok(PlusZero)
                } else {
                    Ok(TakeNum(num))
                }
            } else {
                bail!(val)
            }
        }
        _ => bail!(val),
    }
}

W tej wersji funkcji wykorzystujemy wyrażenie regularne do wyodrębnienia znaku liczby i samej liczby. Jeśli wartość zaczyna się od znaku "+" lub "-", odpowiednio przetwarzamy wartość liczbową. Dzięki takiemu podejściu możemy łatwo zaimplementować walidację, która zwróci odpowiedni błąd, jeśli użytkownik poda nieprawidłowy ciąg.

Co istotne, jeśli wartość jest równa 0 i zaczyna się od "+", funkcja zwróci wariant PlusZero, który oznacza, że liczba jest zero, ale z określonym znakiem. W przeciwnym przypadku, funkcja zwraca liczbę jako TakeNum(num).

rust
Copy code
fn parse_num(val: String) -> Result<TakeNum, Error> {

    let signs: &[char] = &['+', '-'];

    let res = val
        .starts_with(signs)
        .then(|| val.parse())
        .unwrap_or_else(|| val.parse().map(i64::wrapping_neg));
    match res {
        Ok(num) => {

            if num == 0 && val.starts_with('+') {

                Ok(PlusZero)
            } else {
                Ok(TakeNum(num))
            }
        }
        _ => bail!(val),
    }
}

W tej wersji funkcji, sprawdzamy, czy wartość zaczyna się od znaku plusa lub minusa. Jeśli tak, używamy metody str::parse(), która przekształca łańcuch tekstowy na liczbę całkowitą, uwzględniając znak. Jeśli liczba jest równa 0 i zaczyna się od "+", zwracamy wariant PlusZero. W przeciwnym przypadku, zwracamy liczbę w postaci TakeNum(num).

W obu przypadkach istotne jest, aby poprawnie obsługiwać przypadki, w których użytkownik poda nieprawidłowe dane, takie jak "foo" zamiast liczby. Program powinien wtedy zwrócić odpowiedni błąd, jak np. illegal line count -- foo.

• ^ - oznacza początek ciągu,

• [+-] - pasuje do znaku plusa lub minusa,

• \d+ - pasuje do jednej lub więcej cyfr,

• $ - oznacza koniec ciągu.

Po opanowaniu tych podstaw można tworzyć bardziej złożone wyrażenia regularne, które będą odpowiednie do różnych przypadków.

Jednak mimo że wyrażenia regularne mogą wydawać się trudne, są one jednym z najbardziej elastycznych narzędzi do manipulacji tekstem, a w przypadku przetwarzania danych wejściowych stanowią jeden z najlepszych sposobów na efektywną walidację i parsowanie.

Warto pamiętać, że rozwiązanie z użyciem wyrażeń regularnych nie jest jedynym możliwym podejściem w Rust. Istnieje wiele sposobów parsowania danych, w tym wykorzystanie wbudowanych narzędzi i funkcji, które są równie skuteczne, a często prostsze do zaimplementowania, zwłaszcza w mniej wymagających przypadkach.

Jak poprawnie analizować i przetwarzać dane wejściowe dla miesięcy i lat w aplikacjach w Rust

W procesie tworzenia aplikacji w języku Rust, który ma za zadanie obsługiwanie dat, często występuje konieczność analizy danych wejściowych użytkownika, takich jak miesiące i lata. Programowanie w tym zakresie wymaga nie tylko poprawności, ale i elastyczności, by aplikacja mogła obsłużyć zarówno dane liczbowe, jak i tekstowe w sposób intuicyjny. Poniżej przedstawiamy sposób, w jaki można obsługiwać takie dane, bazując na funkcjach i metodach dostępnych w języku Rust.

Pierwszym krokiem w procesie jest zrozumienie, jak należy analizować miesiące. Najprostszą metodą jest wykorzystanie numerów miesięcy w zakresie od 1 do 12. Niemniej jednak, w praktyce, użytkownicy często wprowadzają dane w formie tekstowej, używając skrótów lub pełnych nazw miesięcy. Ważne jest, by program potrafił obsłużyć oba przypadki: zarówno numeryczne wartości, jak i nazwy miesięcy.

Implementacja funkcji parse_month

Funkcja parse_month służy do przetwarzania danych wejściowych, które mogą przybrać formę zarówno liczbową, jak i tekstową. W pierwszej kolejności, funkcja stara się sparsować wejściowy ciąg znaków jako liczbę. Jeśli uda się to zrobić i liczba ta mieści się w zakresie od 1 do 12, zostaje zwrócona jako poprawna wartość miesiąca. W przypadku, gdy wartość jest spoza tego zakresu, funkcja zwraca stosowny komunikat o błędzie.

Przykład implementacji funkcji:

rust
Copy code
const MONTH_NAMES: [&str; 12] = [

    "January", "February", "March", "April", "May", "June", 

    "July", "August", "September", "October", "November", "December",
];
fn parse_month(month: String) -> Result<u32, anyhow::Error> {
    match month.parse() {
        Ok(num) => {

            if (1..=12).contains(&num) {

                Ok(num)
            } else {
                bail!(r#"month "{month}" not in the range 1 through 12"#)
            }
        },
        _ => {
            let lower = &month.to_lowercase();
            let matches: Vec<_> = MONTH_NAMES.iter()
                .enumerate()
                .filter_map(|(i, name)| {
                    if name.to_lowercase().starts_with(lower) {
                        Some(i + 1)
                    } else {
                        None
                    }
                })
                .collect();
            if matches.len() == 1 {

                Ok(matches[0] as u32)

            } else {
                bail!(r#"Invalid month "{month}""#)
            }
        }
    }
}

Obsługa błędów i walidacja

Funkcja parse_month nie tylko przetwarza dane, ale również zapewnia odpowiednią walidację. Jeśli użytkownik poda liczbę, która nie mieści się w zakresie 1-12, zostanie zwrócony błąd z informacją o przekroczeniu zakresu. Dodatkowo, jeśli wprowadzone dane nie odpowiadają żadnemu z miesięcy, użytkownik otrzyma komunikat o błędzie z informacją, że podana nazwa miesiąca jest nieprawidłowa.

Przetwarzanie argumentów w funkcji run

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

    let today = Local::now().date_naive();

    let mut month = args.month.map(parse_month).transpose()?;
    let mut year = args.year;
    if args.show_current_year {
        month = None;
        year = Some(today.year());

    } else if month.is_none() && year.is_none() {

        month = Some(today.month());
        year = Some(today.year());
    }
    let year = year.unwrap_or(today.year());
    println!("month = {month:?}");
    println!("year  = {year:?}");
    Ok(())
}

Wykorzystanie biblioteki Chrono

rust
Copy code
use chrono::{Datelike, Local};

fn run(args: Args) -> Result<()> {

    let today = Local::now().date_naive();

    let mut month = args.month.map(parse_month).transpose()?;

    let mut year = args.year;
    if args.show_current_year {
        month = None;
        year = Some(today.year());
    } else if month.is_none() && year.is_none() {
        month = Some(today.month());
        year = Some(today.year());
    }

    let year = year.unwrap_or(today.year());

    println!("month = {month:?}");
    println!("year  = {year:?}");
    Ok(())
}

Dodatkowe aspekty

Warto zwrócić uwagę na przypadki, które mogą wystąpić podczas analizy danych wejściowych. Należy pamiętać, że chociaż użytkownicy mogą wprowadzać dane w formie skrótów miesięcy lub pełnych nazw, trzeba odpowiednio obsłużyć sytuacje, w których nie jest możliwe jednoznaczne rozpoznanie miesiąca. Na przykład, "Ju" może pasować zarówno do "June", jak i "July", co może prowadzić do niejednoznaczności, którą trzeba rozwiązać.

Ponadto, aplikacja powinna być odporna na błędy związane z wprowadzaniem nieprawidłowych danych, takich jak nieistniejące miesiące ("Fortinbras") lub liczby spoza zakresu 1-12, oraz powinna dawać użytkownikowi informację o błędach w sposób jasny i zrozumiały.