Cum funcționează formatarea șirurilor în Rust

Formatarea șirurilor este un aspect crucial al programării, deoarece vă permite să manipulați și să afișați datele într-o manieră lizibilă și structurată. Puteți controla prezentarea datelor prin formatarea șirurilor pentru o experiență mai bună a utilizatorului.

Rust oferă un mecanism puternic și flexibil pentru formatarea șirurilor care vă permite să creați rezultate clare și concise, inclusiv funcționalități numerice, date, ore și de tratare a erorilor.

Formatarea de bază a șirurilor în Rust

Rust oferă funcționalitate pentru formatarea șirurilor cu altele Tipuri de rugina incorporate.

Puteți folosi format! macro pentru formatarea de bază a șirurilor în Rust. The format! macro oferă o modalitate concisă și puternică de a construi șiruri formatate cu substituenți încadrați în acolade.

fnprincipal() {
lăsa nume = "Alice";
lăsa varsta = 25;
lăsa mesaj = format!(„Numele meu este {} și am {} ani.”, nume, vârstă);
println!("{}", mesaj);
}

The Nume variabila deține un șir, iar vârstă variabila deține un număr întreg. The mesaj variabila are un șir formatat care utilizează format! pentru a înlocui substituenții cu valori corespunzătoare, rezultând un șir de format care conține Nume și vârstă.

The format! macro acceptă diverși specificatori de format care vă permit să controlați rezultatul.

Iată cum să specificați numărul de zecimale pentru numerele cu virgulă mobilă, să definiți lățimea câmpurilor și să aliniați rezultatul.

fnprincipal() {
lăsa pi = 3.14159;
lăsa formatted_pi = format!(„Valoarea lui pi este de aproximativ {:.2}”, pi);
println!("{}", formatat_pi); // imprimă 3.14
}

The pi variabila deține o valoare în virgulă mobilă; cu specificatorul de format :.2, puteți instrui format! macro de afișat pi cu două zecimale.

The format! macro este una dintre numeroasele metode de formatare a șirurilor cu Rust. În funcție de cerințele dvs., luați în considerare utilizarea println! sau scrie! macro pentru ieșirea formatată către consolă sau alte fluxuri de ieșire.

Formatarea valorilor numerice

Rust oferă, de asemenea, funcționalitate pentru formatarea diferitelor valori numerice, de la numere întregi la float și alte tipuri numerice.

În general, specificatorii de format sunt baza formatării șirurilor în Rust și veți avea nevoie de specificatorul potrivit, în funcție de valoarea numerică pe care doriți să o formatați.

Iată câțiva dintre specificatorii de format pe care Rust îi oferă pentru valorile numerice:

În plus, puteți specifica umplutura și alinierea pentru valorile numerice. Umplutura adaugă spații sau zerouri la o valoare numerică formatată pentru a obține lățimea dorită. Umplutura ajută la alinierea valorilor pentru prezentare sub formă tabelară sau alte aspecte organizate vizual. Înainte de valoarea lățimii, puteți specifica caracterul de umplutură, fie un spațiu, fie zero.

Pentru a alinia la stânga o valoare, utilizați - steag. Pentru a alinia la dreapta o valoare, omiteți steagul sau utilizați indicatorul „0” pentru umplerea zero.

fnprincipal() {
 număr = 42
 număr_formatat = „%10d” % număr
 tipărire (număr_formatat)
}

Valoarea este aliniată la dreapta pe o lățime de 10 caractere, rezultând opt spații de început înaintea numărului.

Formatare personalizată a șirurilor în Rust

Formatarea personalizată a șirurilor este importantă pentru operațiuni mai solicitante. Puteți crea implementări de formatare personalizate pentru tipurile dvs. cu ajutorul Rust încorporat std:: fmt modul.

The std:: fmt modulul oferă trăsături pentru formatarea ieșirii cu o gamă largă de opțiuni pentru personalizarea aspectului datelor în timpul procesului de conversie a șirurilor. The std:: fmt modulul oferă a Afişa și Depanați trăsătură care este la îndemână pentru operațiunile de formatare a șirurilor.

Trăsătura de afișare

The Afişa trăsătura ajută la producerea rezultatelor care pot fi citite de om prin definirea modului în care un obiect ar trebui să fie formatat cu {} substituent într-un șir. Puteți implementa Afişa trasatura pentru dvs tipuri personalizate prin definirea unei metode numite fmt care ia un formatator ca argument.

Formatatorul oferă diverse metode de control al ieșirii formatului, cum ar fi scrie_str și scrie_fmt metode.

utilizare std:: fmt;
// Definiți o structură numită `Point`
structPunct {
 X: i32,
 y: i32,
}
// Implementează trăsătura `Display` pentru `Point`
impl fmt:: Afișare pentru Punctul {
fnfmt(&de sine, f: &mut fmt:: Formatator<'_>) -> fmt::Rezultat {
// Formatați structura `Point` ca "(x, y)"
scrie!(f, "({}, {})", de sine.X, de sine.y)
 }
}
fnprincipal() {
// Creați o nouă instanță `Point`
lăsa punct = Punct { x: 5, y: 10 };
// Tipăriți structura `Point` folosind formatarea `Display`
println!(„Ideea este: {}”, punct);
}

The Punct struct implementează Afişa trăsătură. În interiorul fmt metoda, cea scrie! formate macro și scrieți rezultatul dorit la formatator cu ajutorul {} substituent.

Trăsătura de depanare

The Depanați trăsătura este similară cu Afişa trăsătură, cu excepția faptului că se concentrează pe producerea de rezultate adecvate pentru depanare și eroare de manipulare scopuri. The Depanați trăsătura este folosită în principal cu {:?} substituent.

Implementarea Depanați trăsătura pe tipurile dvs. personalizate este simplă. The Depanați trăsătura oferă o implementare implicită bazată pe Afişa trăsătură. Cu toate acestea, puteți suprascrie comportamentul implicit pentru a oferi o reprezentare specializată de depanare.

utilizare std:: fmt;
// Definiți o structură numită `Person`
#[derivare (Depanare)]
structPersoană {
 Nume: Şir,
 vârstă: u32,
}
// Implementează trăsătura `Afișare` pentru `Persoană`
impl fmt:: Afișare pentru Persoana {
fnfmt(&de sine, f: &mut fmt:: Formatator) -> fmt::Rezultat {
// Formatați structura `Person` ca șir care poate fi citit de om
scrie!(f, „Nume: {}, vârsta: {}”, de sine.Nume, de sine.vârstă)
 }
}
fnprincipal() {
// Creați o nouă instanță `Person`
lăsa persoană = Persoană {
 Nume: Şir::din("Alice"),
 vârstă: 30,
 };
// Imprimă structura `Person` folosind formatarea `Display`
println!(„Afișare: {}”, persoană);
// Tipăriți structura `Person` folosind formatarea `Debug`
println!(„Depanare: {:?}”, persoană);
}

Programul derivă Depanați trăsătură pentru Persoană struct cu #[derivare (Depanare)]. Aceasta generează automat implementarea pe baza câmpurilor struct.

Macro-ul println tipărește reprezentarea de depanare cu Depanați substituent de formatare pentru formatarea rezultatului utilizând Depanați implementare.

Rust are un sistem de tip bogat în caracteristici

Sistemul de tip bogat al lui Rust joacă un rol crucial în formatarea șirurilor. Utilizând tastarea statică și bibliotecile puternice de formatare ale Rust, puteți scrie cod sigur și eficient în timp ce gestionați sarcinile de manipulare și formatare a șirurilor.

Sistemul de tip asigură siguranța în timpul compilării și previne erorile comune, de la nepotriviri de tip până la probleme de specificator de format. Cu combinația dintre sistemul de tip Rust și capabilitățile sale extinse de formatare, puteți abordează cu încredere provocările legate de formatarea șirurilor și beneficiază de performanța și siguranța limbii garanții.