Ako funguje formátovanie reťazcov v Rust

Formátovanie reťazcov je kľúčovým aspektom programovania, pretože vám umožňuje manipulovať a zobrazovať údaje čitateľným a štruktúrovaným spôsobom. Prezentáciu údajov môžete ovládať formátovaním reťazcov pre lepšiu používateľskú skúsenosť.

Rust poskytuje výkonný a flexibilný mechanizmus na formátovanie reťazcov, ktorý vám umožňuje vytvárať jasný a stručný výstup, vrátane číselných údajov, dátumu, času a funkcií na odstraňovanie chýb.

Základné formátovanie reťazcov v Rust

Rust poskytuje funkcie na formátovanie reťazcov s inými Hrdzavé vstavané typy.

Môžete použiť formát! makro pre základné formátovanie reťazcov v Rust. The formát! makro poskytuje stručný a účinný spôsob vytvárania formátovaných reťazcov so zástupnými symbolmi uzavretými v zložených zátvorkách.

fnHlavná() {
nech meno = "Alice";
nech vek = 25;
nech správa = formát!("Volám sa {} a mám {} rokov.", meno, vek);
println!("{}", správa);
}

The názov premenná obsahuje reťazec a

Vek premenná obsahuje celé číslo. The správu premenná má formátovaný reťazec, ktorý používa formát! nahradiť zástupné symboly zodpovedajúcimi hodnotami, výsledkom čoho bude formátovací reťazec obsahujúci názov a Vek.

The formát! makro podporuje rôzne špecifikátory formátu, ktoré vám umožňujú ovládať výstup.

Tu je vysvetlené, ako určiť počet desatinných miest pre čísla s pohyblivou rádovou čiarkou, definovať šírku polí a zarovnať výstup.

fnHlavná() {
nech pi = 3.14159;
nech formatted_pi = formát!("Hodnota pi je približne {:.2}", pi);
println!("{}", formatted_pi); // vytlačí 3.14
}

The pi premenná má hodnotu s pohyblivou rádovou čiarkou; so špecifikátorom formátu :.2, môžete inštruovať formát! makro na zobrazenie pi s dvomi desatinnými miestami.

The formát! makro je jednou z mnohých metód formátovania reťazcov pomocou programu Rust. V závislosti od vašich požiadaviek zvážte použitie println! alebo píšte! makro pre formátovaný výstup na konzolu alebo iné výstupné toky.

Formátovanie číselných hodnôt

Rust tiež poskytuje funkcie na formátovanie rôznych číselných hodnôt, od celých čísel po pohyblivé čísla a iné číselné typy.

Vo všeobecnosti sú špecifikátory formátu základom formátovania reťazcov v Ruste a budete potrebovať správny špecifikátor v závislosti od číselnej hodnoty, ktorú chcete formátovať.

Tu sú niektoré zo špecifikátorov formátu, ktoré Rust poskytuje pre číselné hodnoty:

Okrem toho môžete zadať výplň a zarovnanie pre číselné hodnoty. Výplň pridáva medzery alebo nuly k formátovanej číselnej hodnote, aby sa dosiahla požadovaná šírka. Odsadenie pomáha zarovnať hodnoty pre prezentáciu vo forme tabuľky alebo iných vizuálne usporiadaných rozložení. Pred hodnotou šírky môžete zadať výplňový znak, buď medzeru alebo nulu.

Ak chcete hodnotu zarovnať doľava, použite - vlajka. Ak chcete hodnotu zarovnať doprava, vynechajte príznak alebo použite príznak „0“ na odsadenie nuly.

fnHlavná() {
 číslo = 42
 formatted_number = "%10d" % číslo
 vytlačiť (formátované_číslo)
}

Hodnota je zarovnaná doprava v rámci šírky 10 znakov, výsledkom čoho je osem medzier na začiatku pred číslom.

Vlastné formátovanie reťazcov v Rust

Vlastné formátovanie reťazca je dôležité pre náročnejšie operácie. Môžete si vytvoriť vlastné implementácie formátovania pre svoje typy pomocou vstavaného programu Rust std:: fmt modul.

The std:: fmt modul poskytuje vlastnosti pre formátovanie výstupu so širokou škálou možností na prispôsobenie vzhľadu údajov počas procesu konverzie reťazca. The std:: fmt modul poskytuje a Displej a Debug vlastnosť, ktorá je užitočná pri operáciách formátovania reťazcov.

Zobrazovacia vlastnosť

The Displej Táto vlastnosť pomáha vytvárať pre človeka čitateľný výstup tým, že definuje, ako by mal byť objekt naformátovaný pomocou {} zástupný symbol v reťazci. Môžete implementovať Displej vlastnosť pre vaše vlastné typy definovaním metódy tzv fmt ktorý berie ako argument formátovač.

Formátovač poskytuje rôzne metódy na riadenie výstupu formátu, ako napr write_str a write_fmt metódy.

použitie std:: fmt;
// Definujte štruktúru s názvom `Point`
štrukturovaťBod {
 X: i32,
 y: i32,
}
// Implementujte vlastnosť `Display` pre `Point`
impl fmt:: Displej pre Bod {
fnfmt(&seba, f: &mut fmt:: Formátovač<'_>> -> fmt::Výsledok {
// Naformátujte štruktúru "Point" ako "(x, y)"
píšte!(f, "({}, {})", seba.X, seba.y)
 }
}
fnHlavná() {
// Vytvorenie novej inštancie `Point`
nech bod = bod { x: 5, y: 10 };
// Vytlačí štruktúru `Point` pomocou formátovania `Display`
println!("Pointa je: {}", bod);
}

The Bod struct implementuje Displej vlastnosť. Vnútri fmt metóda, píšte! makro formáty a zapíšte požadovaný výstup do formátovača pomocou {} zástupný symbol.

Vlastnosť ladenia

The Debug vlastnosť je podobná Displej okrem toho, že sa zameriava na produkciu výstupu vhodného na ladenie a spracovanie chýb účely. The Debug vlastnosť sa používa hlavne s {:?} zástupný symbol.

Implementácia Debug Vlastnosť vašich vlastných typov je jednoduchá. The Debug vlastnosť poskytuje predvolenú implementáciu založenú na Displej vlastnosť. Predvolené správanie však môžete prepísať a poskytnúť tak špecializovanú reprezentáciu ladenia.

použitie std:: fmt;
// Definujte štruktúru s názvom `Person`
#[derive (Debug)]
štrukturovaťOsoba {
 názov: Reťazec,
 Vek: u32,
}
// Implementujte vlastnosť `Display` pre `Person`
impl fmt:: Displej pre Osoba {
fnfmt(&seba, f: &mut fmt:: Formátovač) -> fmt::Výsledok {
// Naformátujte štruktúru `Person` ako ľudsky čitateľný reťazec
píšte!(f, "Meno: {}, vek: {}", seba.názov, seba.Vek)
 }
}
fnHlavná() {
// Vytvorenie novej inštancie `Person`
nech osoba = Osoba {
 názov: Reťazec::od("Alice"),
 Vek: 30,
 };
// Vytlačí štruktúru `Person` pomocou formátovania `Display`
println!("Zobraziť: {}", osoba);
// Vytlačí štruktúru `Person` pomocou formátovania `Debug`
println!("Ladenie: {:?}", osoba);
}

Program odvodzuje Debug vlastnosť pre Osoba štrukturovať s #[derive (Debug)]. Toto automaticky vygeneruje implementáciu na základe polí struct.

Makro println vytlačí reprezentáciu ladenia s Debug formátovací zástupný symbol na formátovanie výstupu pomocou Debug implementáciu.

Rust má typový systém bohatý na funkcie

Rustov bohatý typový systém hrá kľúčovú úlohu pri formátovaní reťazcov. Využitím statického písania a výkonných formátovacích knižníc Rust môžete písať bezpečný a efektívny kód pri manipulácii s reťazcami a úlohách formátovania.

Typový systém zaisťuje bezpečnosť počas kompilácie a zabraňuje bežným chybám, od nezhody typov po problémy so špecifikátormi formátu. S kombináciou typového systému Rust a jeho rozsiahlych možností formátovania môžete s istotou riešiť problémy s formátovaním reťazcov a profitovať z výkonu a bezpečnosti jazyka záruky.