Kā stīgu formatēšana darbojas rūsā

Virknes formatēšana ir būtisks programmēšanas aspekts, jo tas ļauj manipulēt un parādīt datus lasāmā, strukturētā veidā. Varat kontrolēt datu prezentāciju, formatējot virknes, lai nodrošinātu labāku lietotāja pieredzi.

Rust nodrošina jaudīgu un elastīgu virkņu formatēšanas mehānismu, kas ļauj izveidot skaidru un kodolīgu izvadi, tostarp ciparu, datuma, laika un kļūdu apstrādes funkcionalitāti.

Pamata virkņu formatēšana rūsā

Rust nodrošina funkcionalitāti virkņu formatēšanai ar citām Rūsas iebūvētie veidi.

Jūs varat izmantot formātā! makro virknes pamata formatēšanai programmā Rust. The formātā! makro nodrošina īsu un jaudīgu veidu, kā izveidot formatētas virknes ar vietturi, kas ietverti krokainajās iekavās.

fngalvenais() {
ļaut vārds = "Alise";
ļaut vecums = 25;
ļaut ziņa = formātā!("Mani sauc {}, un man ir {} gadi.", vārds, vecums);
println!("{}", ziņa);
}

The nosaukums mainīgajam ir virkne, un vecums mainīgajam ir vesels skaitlis. The

ziņa mainīgajam ir formatēta virkne, kas izmanto formātā! lai aizstātu vietturus ar atbilstošām vērtībām, kā rezultātā tiek iegūta formāta virkne, kurā ir nosaukums un vecums.

The formātā! makro atbalsta dažādus formātu specifikācijas, kas ļauj kontrolēt izvadi.

Tālāk ir norādīts, kā norādīt peldošā komata skaitļu decimāldaļu skaitu, definēt lauku platumu un līdzināt izvadi.

fngalvenais() {
ļaut pi = 3.14159;
ļaut formatted_pi = formātā!("Pi vērtība ir aptuveni {:.2}", pi);
println!("{}", formatēts_pi); // izdrukas 3.14
}

The pi mainīgajam ir peldošā komata vērtība; ar formāta norādītāju :.2, varat norādīt formātā! parādāmais makro pi ar divām zīmēm aiz komata.

The formātā! makro ir viena no daudzajām virkņu formatēšanas metodēm, izmantojot Rust. Atkarībā no jūsu prasībām apsveriet iespēju izmantot println! vai raksti! makro formatētai izvadei uz konsoli vai citām izvades straumēm.

Skaitlisko vērtību formatēšana

Rust nodrošina arī dažādu skaitlisko vērtību formatēšanas funkcionalitāti, sākot no veseliem skaitļiem līdz pludiņiem un citiem skaitļu veidiem.

Parasti formāta specifikācijas ir virkņu formatēšanas pamats programmā Rust, un jums būs nepieciešams pareizais norādītājs atkarībā no skaitliskās vērtības, kuru vēlaties formatēt.

Šeit ir daži no formāta specifikācijām, ko Rust nodrošina skaitliskām vērtībām:

Turklāt varat norādīt skaitlisko vērtību polsterējumu un līdzinājumu. Polsterējums formatētai skaitliskai vērtībai pievieno atstarpes vai nulles, lai sasniegtu vēlamo platumu. Polsterējums palīdz līdzināt vērtības prezentācijai tabulas formā vai citos vizuāli organizētos izkārtojumos. Pirms platuma vērtības varat norādīt polsterējuma rakstzīmi — atstarpi vai nulli.

Lai līdzinātu vērtību pa kreisi, izmantojiet - karogs. Lai vērtību līdzinātu pa labi, izlaidiet karogu vai izmantojiet karodziņu “0” nulles polsterējumam.

fngalvenais() {
 skaitlis = 42
 formatēts_skaitlis = "%10d" % skaitlis
 drukāt (formatēts_numurs)
}

Vērtība ir līdzināta pa labi 10 rakstzīmju platumā, kā rezultātā pirms skaitļa ir astoņas atstarpes.

Pielāgots virknes formatējums rūsā

Pielāgots virknes formatējums ir svarīgs prasīgākām darbībām. Izmantojot Rust iebūvēto, varat izveidot pielāgotas formatēšanas implementācijas saviem tipiem std:: fmt modulis.

The std:: fmt modulis nodrošina izvades formatēšanas iezīmes ar plašām iespējām datu izskata pielāgošanai virknes konvertēšanas procesa laikā. The std:: fmt modulis nodrošina a Displejs un Atkļūdošana īpašība, kas ir ērta virkņu formatēšanas darbībām.

Displeja iezīme

The Displejs īpašība palīdz radīt cilvēkiem lasāmu izvadi, definējot, kā objekts ir jāformatē ar {} vietturis virknē. Jūs varat īstenot Displejs īpašība jums pielāgoti veidi definējot metodi, ko sauc fmt kas izmanto formatētāju kā argumentu.

Formatētājs nodrošina dažādas metodes formāta izvades kontrolei, piemēram, write_str un write_fmt metodes.

izmantot std:: fmt;
// Definējiet struktūru ar nosaukumu "Punkts".
struktūraPunkts {
 x: i32,
 y: i32,
}
// Ieviesiet elementam 'Punkts' iezīmi Displejs
impl fmt:: Displejs priekš Punkts {
fnfmt(&sevi, f: &mut fmt:: Formatētājs<'_>> -> fmt::Rezultāts {
// Formatējiet `Point` struktūru kā "(x, y)"
raksti!(f, "({}, {})", sevi.x, sevi.y)
 }
}
fngalvenais() {
// Izveidojiet jaunu Point instanci
ļaut punkts = punkts { x: 5, y: 10 };
// Izdrukājiet struktūru "Punkts", izmantojot formatējumu "Displejs".
println!(Lieta ir šāda: {}, punkts);
}

The Punkts struct īsteno Displejs īpašība. Iekšpusē fmt metode, raksti! makro formātus un ierakstiet vēlamo izvadi formatētājā ar {} vietturis.

Atkļūdošanas iezīme

The Atkļūdošana īpašība ir līdzīga Displejs īpašība, izņemot to, ka tā koncentrējas uz atkļūdošanai un atkļūdošanai piemērotas produkcijas ražošanu kļūdu apstrāde mērķiem. The Atkļūdošana īpašība galvenokārt tiek izmantota kopā ar {:?} vietturis.

Īstenojot Atkļūdošana jūsu pielāgoto veidu iezīme ir vienkārša. The Atkļūdošana iezīme nodrošina noklusējuma ieviešanu, pamatojoties uz Displejs īpašība. Tomēr varat ignorēt noklusējuma darbību, lai nodrošinātu specializētu atkļūdošanas attēlojumu.

izmantot std:: fmt;
// Definējiet struktūru ar nosaukumu Persona
#[atvasināt (atkļūdot)]
struktūraPersona {
 nosaukums: Stīga,
 vecums: u32,
}
// Ieviesiet elementam "Persona" iezīmi Displejs
impl fmt:: Displejs priekš Persona {
fnfmt(&sevi, f: &mut fmt:: Formatētājs) -> fmt::Rezultāts {
// Formatējiet struktūru "Persona" kā cilvēkam lasāmu virkni
raksti!(f, "Vārds: {}, vecums: {}", sevi.name, sevi.vecums)
 }
}
fngalvenais() {
// Izveidojiet jaunu "Personas" gadījumu
ļaut persona = persona {
 nosaukums: Stīga::no("Alise"),
 vecums: 30,
 };
// Izdrukājiet struktūru "Persona", izmantojot formatējumu "Displejs".
println!("Displejs: {}", persona);
// Izdrukājiet struktūru "Person", izmantojot formatējumu "Debug".
println!("Atkļūdot: {:?}", persona);
}

Programma iegūst Atkļūdošana īpašība priekš Persona strukturēt ar #[atvasināt (atkļūdot)]. Tas automātiski ģenerē ieviešanu, pamatojoties uz struct laukiem.

Println makro izdrukā atkļūdošanas attēlojumu ar Atkļūdošana formatēšanas vietturis izvades formatēšanai, izmantojot Atkļūdošana īstenošana.

Rūsai ir ar funkcijām bagāta tipa sistēma

Rust bagātīgā tipa sistēmai ir izšķiroša loma virkņu formatēšanā. Izmantojot Rust statisko rakstīšanu un jaudīgās formatēšanas bibliotēkas, varat rakstīt drošu, efektīvu kodu, vienlaikus apstrādājot virknes manipulācijas un formatēšanas uzdevumus.

Tipu sistēma nodrošina kompilēšanas laika drošību un novērš bieži sastopamas kļūdas, sākot no tipu neatbilstības līdz formāta specifikācijas problēmām. Izmantojot Rust tipa sistēmu un tās plašās formatēšanas iespējas, jūs varat pārliecinoši risiniet virkņu formatēšanas problēmas un gūstiet labumu no valodas veiktspējas un drošības garantijas.