Sådan fungerer strengformatering i rust

Strengformatering er et afgørende aspekt af programmering, da det lader dig manipulere og vise data på en læsbar, struktureret måde. Du kan styre datapræsentationen ved at formatere strenge for en bedre brugeroplevelse.

Rust giver en kraftfuld og fleksibel mekanisme til strengformatering, der giver dig mulighed for at skabe klare og præcise output, inklusive numerisk, dato, klokkeslæt og fejlhåndteringsfunktionalitet.

Grundlæggende strengformatering i rust

Rust giver funktionalitet til at formatere strenge med andre Rust indbyggede typer.

Du kan bruge format! makro til grundlæggende strengformatering i Rust. Det format! makro giver en kortfattet og kraftfuld måde at konstruere formaterede strenge med pladsholdere omsluttet af krøllede klammeparenteser.

fnvigtigste() {
lade navn = "Alice";
lade alder = 25;
lade besked = format!("Mit navn er {} og jeg er {} år gammel.", navn, alder);
println!("{}", besked);
}

Det navn variabel indeholder en streng, og

alder variabel har et heltal. Det besked variabel har en formateret streng, der bruger format! at erstatte pladsholderne med tilsvarende værdier, hvilket resulterer i en formatstreng, der indeholder navn og alder.

Det format! makro understøtter forskellige formatspecifikationer, der giver dig mulighed for at styre outputtet.

Sådan angiver du antallet af decimaler for flydende kommatal, definerer felternes bredde og justerer outputtet.

fnvigtigste() {
lade pi = 3.14159;
lade formatted_pi = format!("Værdien af ​​pi er cirka {:.2}", pi);
println!("{}", formateret_pi); // udskriver 3.14
}

Det pi variabel har en flydende kommaværdi; med formatspecifikationen :.2, kan du instruere format! makro at vise pi med to decimaler.

Det format! makro er en af ​​de mange metoder til strengformatering med Rust. Afhængigt af dine krav kan du overveje at bruge println! eller skrive! makro til formateret output til konsollen eller andre outputstrømme.

Formatering af numeriske værdier

Rust giver også funktionalitet til formatering af forskellige numeriske værdier, fra heltal til flydende og andre numeriske typer.

Generelt er formatspecifikationer grundlaget for strengformatering i Rust, og du skal bruge den rigtige specifikation afhængigt af den numeriske værdi, du vil formatere.

Her er nogle af formatspecifikationerne Rust giver til numeriske værdier:

Derudover kan du angive polstring og justering for numeriske værdier. Udfyldningen tilføjer mellemrum eller nuller til en formateret numerisk værdi for at opnå en ønsket bredde. Padding hjælper med at justere værdier til præsentation i tabelform eller andre visuelt organiserede layouts. Før breddeværdien kan du angive udfyldningstegnet, enten et mellemrum eller nul.

For at venstrejustere en værdi skal du bruge - flag. For at højrejustere en værdi skal du udelade flaget eller bruge '0'-flaget til nuludfyldning.

fnvigtigste() {
 nummer = 42
 formateret_tal = "%10d" % nummer
 print (formateret_nummer)
}

Værdien er højrejusteret inden for en bredde på 10 tegn, hvilket resulterer i otte mellemrum foran tallet.

Brugerdefineret strengformatering i rust

Tilpasset strengformatering er vigtig for mere krævende operationer. Du kan oprette brugerdefinerede formateringsimplementeringer til dine typer med Rusts indbyggede std:: fmt modul.

Det std:: fmt modul giver egenskaber til formatering af output med en bred vifte af muligheder for at tilpasse dataudseende under strengkonverteringsprocessen. Det std:: fmt modul giver en Skærm og Fejlfinde egenskab, der er praktisk til strengformateringsoperationer.

Displayegenskaben

Det Skærm egenskab hjælper med at producere menneskelæsbart output ved at definere, hvordan et objekt skal formateres med {} pladsholder i en streng. Du kan implementere Skærm egenskab for din brugerdefinerede typer ved at definere en metode kaldet fmt der tager en formatter som argument.

Formateringsværktøjet giver forskellige metoder til at styre formatoutput, som f.eks skrive_str og skrive_fmt metoder.

brug std:: fmt;
// Definer en struktur med navnet `Point`
strukturPunkt {
 x: i32,
 y: i32,
}
// Implementer 'Display'-egenskaben for 'Point'
impl fmt:: Display til Punkt {
fnfmt(&selv, f: &mut fmt:: Formater<'_>) -> fmt::Resultat {
// Formater `Punkt`-strukturen som "(x, y)"
skrive!(f, "({}, {})", selv.x, selv.y)
 }
}
fnvigtigste() {
// Opret en ny `Point`-instans
lade punkt = Punkt { x: 5, y: 10 };
// Udskriv `Point`-strukturen ved at bruge `Display`-formateringen
println!("Pointen er: {}", punkt);
}

Det Punkt struct implementerer Skærm egenskab. Inde i fmt metode, den skrive! makroformater og skriv det ønskede output til formateringsværktøjet med {} pladsholder.

Debug-egenskaben

Det Fejlfinde egenskab ligner Skærm egenskab, bortset fra at det fokuserer på at producere output, der er egnet til fejlretning og fejlhåndtering formål. Det Fejlfinde egenskab bruges hovedsageligt sammen med {:?} pladsholder.

Implementering af Fejlfinde egenskab på dine brugerdefinerede typer er ligetil. Det Fejlfinde egenskab giver en standardimplementering baseret på Skærm egenskab. Du kan dog tilsidesætte standardadfærden for at give en specialiseret fejlfindingsrepræsentation.

brug std:: fmt;
// Definer en struktur ved navn `Person`
#[aflede (debug)]
strukturPerson {
 navn: Snor,
 alder: u32,
}
// Implementer "Vis"-egenskaben for "Person".
impl fmt:: Display til Person {
fnfmt(&selv, f: &mut fmt:: Formatter) -> fmt::Resultat {
// Formater `Person`-strukturen som en menneskelig læsbar streng
skrive!(f, "Navn: {}, Alder: {}", selv.navn, selv.alder)
 }
}
fnvigtigste() {
// Opret en ny `Person`-instans
lade person = Person {
 navn: Snor::fra("Alice"),
 alder: 30,
 };
// Udskriv `Person`-strukturen ved at bruge `Display`-formateringen
println!("Skærm: {}", person);
// Udskriv `Person`-strukturen ved hjælp af `Debug`-formateringen
println!("Fejlfinde: {:?}", person);
}

Programmet udleder Fejlfinde egenskab for Person strukturere med #[aflede (debug)]. Dette genererer automatisk implementeringen baseret på struct-felterne.

Println-makroen udskriver fejlfindingsrepræsentationen med Fejlfinde formateringspladsholder til formatering af output ved hjælp af Fejlfinde implementering.

Rust har et funktionsrigt typesystem

Rusts rige typesystem spiller en afgørende rolle i strengformatering. Ved at udnytte Rusts statiske indtastning og kraftfulde formateringsbiblioteker kan du skrive sikker, effektiv kode, mens du håndterer strengmanipulation og formateringsopgaver.

Typesystemet sikrer kompileringssikkerhed og forhindrer almindelige fejl, fra typeuoverensstemmelser til formatspecifikationsproblemer. Med kombinationen af ​​Rusts typesystem og dets omfattende formateringsmuligheder kan du tackle med sikkerhed strengformateringsudfordringer og drage fordel af sprogets ydeevne og sikkerhed garantier.