Jak działa formatowanie łańcuchów w Rust

Formatowanie ciągów znaków jest kluczowym aspektem programowania, ponieważ umożliwia manipulowanie danymi i wyświetlanie ich w czytelny, ustrukturyzowany sposób. Możesz kontrolować prezentację danych, formatując ciągi, aby zapewnić lepszą obsługę.

Rust zapewnia potężny i elastyczny mechanizm formatowania ciągów znaków, który umożliwia tworzenie jasnych i zwięzłych danych wyjściowych, w tym funkcji liczbowych, daty, czasu i obsługi błędów.

Podstawowe formatowanie łańcuchów w Rust

Rust zapewnia funkcjonalność do formatowania ciągów z innymi Typy wbudowane w rdzę.

Możesz użyć format! makro do podstawowego formatowania łańcuchów znaków w Rust. The format! makro zapewnia zwięzły i wydajny sposób konstruowania sformatowanych ciągów znaków z symbolami zastępczymi ujętymi w nawiasy klamrowe.

przypgłówny() {
pozwalać imię = „Alicja”;
pozwalać wiek = 25;
pozwalać wiadomość = format!(„Nazywam się {} i mam {} lat”., imię Wiek);
drukuj!("{}", wiadomość);
}

The nazwa zmienna zawiera łańcuch, a wiek zmienna zawiera liczbę całkowitą. The wiadomość zmienna ma sformatowany ciąg, który wykorzystuje format! aby zastąpić symbole zastępcze odpowiednimi wartościami, co spowoduje powstanie łańcucha formatu zawierającego nazwa I wiek.

The format! makro obsługuje różne specyfikatory formatu, które umożliwiają sterowanie danymi wyjściowymi.

Oto jak określić liczbę miejsc po przecinku dla liczb zmiennoprzecinkowych, zdefiniować szerokość pól i wyrównać dane wyjściowe.

przypgłówny() {
pozwalać pi = 3.14159;
pozwalać sformatowane_pi = format!(„Wartość pi wynosi około {:.2}”, Liczba Pi);
drukuj!("{}", sformatowane_pi); // drukuje 3.14
}

The Liczba Pi zmienna przechowuje wartość zmiennoprzecinkową; ze specyfikatorem formatu :.2, możesz poinstruować format! makro do wyświetlenia Liczba Pi z dwoma miejscami po przecinku.

The format! makro jest jedną z wielu metod formatowania napisów w Ruście. W zależności od wymagań rozważ użycie drukuj! Lub pisać! makro do sformatowanego wyjścia do konsoli lub innych strumieni wyjściowych.

Formatowanie wartości liczbowych

Rust zapewnia również funkcjonalność formatowania różnych wartości liczbowych, od liczb całkowitych po zmiennoprzecinkowe i inne typy liczbowe.

Ogólnie rzecz biorąc, specyfikatory formatu są podstawą formatowania ciągów znaków w Rust i będziesz potrzebować odpowiedniego specyfikatora w zależności od wartości liczbowej, którą chcesz sformatować.

Oto niektóre specyfikatory formatu, które Rust zapewnia dla wartości numerycznych:

Dodatkowo można określić dopełnienie i wyrównanie dla wartości liczbowych. Wypełnienie dodaje spacje lub zera do sformatowanej wartości liczbowej, aby uzyskać żądaną szerokość. Dopełnienie pomaga wyrównać wartości do prezentacji w formie tabelarycznej lub innych wizualnie zorganizowanych układów. Przed wartością szerokości można określić znak dopełnienia, spację lub zero.

Aby wyrównać wartość do lewej, użyj - flaga. Aby wyrównać wartość do prawej, pomiń flagę lub użyj flagi „0” dla dopełnienia zerami.

przypgłówny() {
 liczba = 42
 sformatowany_numer = "%10d" liczba %
 drukuj (sformatowany_numer)
}

Wartość jest wyrównana do prawej na szerokości 10 znaków, co daje osiem wiodących spacji przed liczbą.

Niestandardowe formatowanie ciągów w Rust

Niestandardowe formatowanie ciągów jest ważne w przypadku bardziej wymagających operacji. Możesz tworzyć niestandardowe implementacje formatowania dla swoich typów za pomocą wbudowanego Rusta std:: fmt moduł.

The std:: fmt zapewnia cechy formatowania danych wyjściowych z szeroką gamą opcji dostosowywania wyglądu danych podczas procesu konwersji ciągów znaków. The std:: fmt moduł zapewnia Wyświetlacz I Odpluskwić cecha, która jest przydatna w operacjach formatowania łańcuchów.

Cecha wyświetlania

The Wyświetlacz cecha pomaga generować dane wyjściowe czytelne dla człowieka, definiując, w jaki sposób obiekt powinien być sformatowany za pomocą {} symbol zastępczy w ciągu. Możesz wdrożyć tzw Wyświetlacz cecha dla Ciebie typy niestandardowe poprzez zdefiniowanie metody tzw fmt który przyjmuje program formatujący jako argument.

Program formatujący udostępnia różne metody kontrolowania danych wyjściowych formatu, np napisz_str I napisz_fmt metody.

używać std:: fmt;
// Zdefiniuj strukturę o nazwie `Point`
strukturaPunkt {
 X: i32,
 y: i32,
}
// Zaimplementuj cechę `Display` dla `Point`
implik fmt:: Wyświetl Do Punkt {
przypfmt(&samego siebie, F: &mut fmt:: Formater<'_>) -> fmt::Wynik {
// Sformatuj strukturę `Point` jako "(x, y)"
pisać!(F, "({}, {})", samego siebie.X, samego siebiey)
 }
}
przypgłówny() {
// Utwórz nową instancję `Point`
pozwalać punkt = punkt {x: 5, y: 10 };
// Wydrukuj strukturę `Point` używając formatowania `Display`
drukuj!("Chodzi o to: {}", punkt);
}

The Punkt struct implementuje Wyświetlacz cecha. W środku fmt metoda, tzw pisać! formaty makr i zapisz żądane dane wyjściowe do formatyzatora za pomocą {} symbol zastępczy

Cecha debugowania

The Odpluskwić cecha jest podobna do Wyświetlacz cecha, z wyjątkiem tego, że koncentruje się na tworzeniu danych wyjściowych odpowiednich do debugowania i obsługa błędów cele. The Odpluskwić Cecha jest używana głównie z {:?} symbol zastępczy

Wdrażanie Odpluskwić cecha na twoich niestandardowych typach jest prosta. The Odpluskwić cecha zapewnia domyślną implementację opartą na Wyświetlacz cecha. Można jednak zastąpić domyślne zachowanie, aby zapewnić wyspecjalizowaną reprezentację debugowania.

używać std:: fmt;
// Zdefiniuj strukturę o nazwie `Person`
#[pochodna (debugowanie)]
strukturaOsoba {
 nazwa: Strunowy,
 wiek: u32,
}
// Zaimplementuj cechę `Display` dla `Person`
implik fmt:: Wyświetl Do Osoba {
przypfmt(&samego siebie, F: &mut fmt:: Formater) -> fmt::Wynik {
// Sformatuj strukturę `Person` jako ciąg czytelny dla człowieka
pisać!(F, "Imię Wiek: {}", samego siebie.nazwa, samego siebie.wiek)
 }
}
przypgłówny() {
// Utwórz nową instancję `Person`
pozwalać osoba = osoba {
 nazwa: Strunowy::z(„Alicja”),
 wiek: 30,
 };
// Wydrukuj strukturę `Person` używając formatowania `Display`
drukuj!("Wyświetlacz: {}", osoba);
// Wydrukuj strukturę `Person` używając formatowania `Debug`
drukuj!(„Debugowanie: {:?}”, osoba);
}

Program wyprowadza Odpluskwić cecha dla Osoba struktura z #[pochodna (debugowanie)]. Spowoduje to automatyczne wygenerowanie implementacji na podstawie pól struktury.

Makro println drukuje reprezentację debugowania z rozszerzeniem Odpluskwić symbol zastępczy formatowania do formatowania danych wyjściowych przy użyciu Odpluskwić realizacja.

Rust ma bogaty w funkcje system typów

Bogaty system typów w Rust odgrywa kluczową rolę w formatowaniu ciągów znaków. Wykorzystując statyczne typowanie i potężne biblioteki formatowania Rusta, możesz pisać bezpieczny, wydajny kod, jednocześnie obsługując zadania manipulacji łańcuchami i formatowania.

System typów zapewnia bezpieczeństwo podczas kompilacji i zapobiega typowym błędom, od niezgodności typów po problemy ze specyfikacją formatu. Dzięki połączeniu systemu czcionek Rusta i jego rozbudowanych możliwości formatowania, możesz śmiało stawić czoła wyzwaniom związanym z formatowaniem ciągów znaków i korzystać z wydajności i bezpieczeństwa języka gwarancje.