Hvordan strengformatering fungerer i rust

Strengformatering er et avgjørende aspekt ved programmering siden det lar deg manipulere og vise data på en lesbar, strukturert måte. Du kan kontrollere datapresentasjonen ved å formatere strenger for en bedre brukeropplevelse.

Rust gir en kraftig og fleksibel mekanisme for strengformatering som gir deg mulighet til å lage klare og konsise utdata, inkludert numerisk, dato, klokkeslett og feilhåndteringsfunksjonalitet.

Grunnleggende strengformatering i rust

Rust gir funksjonalitet for formatering av strenger med andre Rust innebygde typer.

Du kan bruke format! makro for grunnleggende strengformatering i Rust. De format! makro gir en kortfattet og kraftig måte å konstruere formaterte strenger med plassholdere omsluttet av krøllete klammeparenteser.

fnhoved-() {
la navn = "Alice";
la alder = 25;
la melding = format!("Mitt navn er {} og jeg er {} år gammel.", navn Alder);
println!("{}", beskjed);
}

De Navn variabelen inneholder en streng, og

alder variabel inneholder et heltall. De beskjed variabelen har en formatert streng som bruker format! for å erstatte plassholderne med tilsvarende verdier, noe som resulterer i en formatstreng som inneholder Navn og alder.

De format! makro støtter ulike formatspesifikasjoner som lar deg kontrollere utdataene.

Slik angir du antall desimaler for flyttall, definerer bredden på feltene og justerer utdataene.

fnhoved-() {
la pi = 3.14159;
la formatted_pi = format!("Verdien av pi er omtrentlig {:.2}", pi);
println!("{}", formatert_pi); // utskrifter 3.14
}

De pi variabelen har en flyttallsverdi; med formatspesifikasjonen :.2, kan du instruere format! makro som skal vises pi med to desimaler.

De format! makro er en av de mange metodene for strengformatering med Rust. Avhengig av dine behov, vurder å bruke println! eller skrive! makro for formatert utdata til konsollen eller andre utdatastrømmer.

Formatering av numeriske verdier

Rust gir også funksjonalitet for formatering av ulike numeriske verdier, fra heltall til flyter og andre numeriske typer.

Vanligvis er formatspesifikasjoner grunnlaget for strengformatering i Rust, og du trenger den riktige spesifikasjonen avhengig av den numeriske verdien du vil formatere.

Her er noen av formatspesifikasjonene Rust gir for numeriske verdier:

I tillegg kan du spesifisere utfylling og justering for numeriske verdier. Utfyllingen legger til mellomrom eller nuller til en formatert numerisk verdi for å oppnå ønsket bredde. Utfylling hjelper til med å justere verdier for presentasjon i tabellform eller andre visuelt organiserte oppsett. Før breddeverdien kan du spesifisere utfyllingstegnet, enten et mellomrom eller null.

For å venstrejustere en verdi, bruk - flagg. For å høyrejustere en verdi, utelate flagget eller bruk '0'-flagget for nullutfylling.

fnhoved-() {
 tall = 42
 formatert_nummer = "%10d" % Antall
 print (formatert_nummer)
}

Verdien er høyrejustert innenfor en bredde på 10 tegn, noe som resulterer i åtte mellomrom foran tallet.

Egendefinert strengformatering i rust

Tilpasset strengformatering er viktig for mer krevende operasjoner. Du kan lage tilpassede formateringsimplementeringer for typene dine med Rusts innebygde std:: fmt modul.

De std:: fmt modulen gir egenskaper for formatering av utdata med et bredt spekter av alternativer for å tilpasse datautseendet under strengkonverteringsprosessen. De std:: fmt modul gir en Vise og Feilsøk egenskap som er nyttig for strengformateringsoperasjoner.

Visningstrekket

De Vise egenskap bidrar til å produsere lesbare utdata ved å definere hvordan et objekt skal formateres med {} plassholder i en streng. Du kan implementere Vise egenskap for din tilpassede typer ved å definere en metode kalt fmt som tar en formater som argument.

Formateringsverktøyet gir forskjellige metoder for å kontrollere formatutdata, for eksempel skrive_str og skrive_fmt metoder.

bruk std:: fmt;
// Definer en struktur kalt `Point`
strukturPunkt {
 x: i32,
 y: i32,
}
// Implementer "Display"-trekk for "Point".
impl fmt:: Display til Punkt {
fnfmt(&selv-, f: &mut fmt:: Formater<'_>) -> fmt::Resultat {
// Formater `Point`-strukturen som "(x, y)"
skrive!(f, "({}, {})", selv-.x, selv-.y)
 }
}
fnhoved-() {
// Opprett en ny "Point"-forekomst
la punkt = Punkt { x: 5, y: 10 };
// Skriv ut `Point`-strukturen ved å bruke `Display`-formateringen
println!("Poenget er: {}", punkt);
}

De Punkt struct implementerer Vise trekk. Inne i fmt metoden, den skrive! makroformater og skriv ønsket utdata til formateringsmaskinen med {} plassholder.

Feilsøkingstrekket

De Feilsøk egenskap ligner på Vise egenskap, bortsett fra at den fokuserer på å produsere utdata som er egnet for feilsøking og feilhåndtering formål. De Feilsøk egenskap brukes hovedsakelig med {:?} plassholder.

Implementering av Feilsøk egenskapen til dine tilpassede typer er grei. De Feilsøk egenskap gir en standardimplementering basert på Vise trekk. Du kan imidlertid overstyre standardoppførselen for å gi en spesialisert feilsøkingsrepresentasjon.

bruk std:: fmt;
// Definer en struktur kalt `Person`
#[avlede (feilsøke)]
strukturPerson {
 Navn: String,
 alder: u32,
}
// Implementer "Vis"-trekk for "Person".
impl fmt:: Display til Person {
fnfmt(&selv-, f: &mut fmt:: Formatter) -> fmt::Resultat {
// Formater `Person`-strukturen som en menneskelig lesbar streng
skrive!(f, "Navn Alder: {}", selv-.Navn, selv-.alder)
 }
}
fnhoved-() {
// Opprett en ny `Person`-forekomst
la person = Person {
 Navn: String::fra("Alice"),
 alder: 30,
 };
// Skriv ut `Person`-strukturen ved å bruke `Display`-formateringen
println!("Vise: {}", person);
// Skriv ut `Person`-strukturen ved å bruke `Debug`-formateringen
println!("Feilsøk: {:?}", person);
}

Programmet utleder Feilsøk egenskap for Person struktur med #[avlede (feilsøke)]. Dette genererer automatisk implementeringen basert på struct-feltene.

Println-makroen skriver ut feilsøkingsrepresentasjonen med Feilsøk formateringsplassholder for formatering av utdata ved hjelp av Feilsøk gjennomføring.

Rust har et funksjonsrikt system

Rusts rike typesystem spiller en avgjørende rolle i strengformatering. Ved å utnytte Rusts statiske skriving og kraftige formateringsbiblioteker, kan du skrive sikker, effektiv kode mens du håndterer strengmanipulering og formateringsoppgaver.

Typesystemet sikrer kompileringssikkerhet og forhindrer vanlige feil, fra typefeil til formatspesifikasjonsproblemer. Med kombinasjonen av Rusts typesystem og dets omfattende formateringsmuligheter kan du takle strengformateringsutfordringer trygt og dra nytte av språkets ytelse og sikkerhet garantier.