Hoe tekenreeksopmaak werkt in Rust

Tekenreeksopmaak is een cruciaal aspect van programmeren, omdat u hiermee gegevens op een leesbare, gestructureerde manier kunt manipuleren en weergeven. U kunt de gegevenspresentatie regelen door tekenreeksen op te maken voor een betere gebruikerservaring.

Rust biedt een krachtig en flexibel mechanisme voor tekenreeksopmaak waarmee u duidelijke en beknopte uitvoer kunt maken, inclusief numerieke, datum-, tijd- en foutafhandelingsfunctionaliteit.

Basisreeksopmaak in roest

Rust biedt functionaliteit voor het formatteren van tekenreeksen met andere Roest ingebouwde types.

U kunt de formaat! macro voor standaard tekenreeksopmaak in Rust. De formaat! macro biedt een beknopte en krachtige manier om opgemaakte tekenreeksen te construeren met tijdelijke aanduidingen tussen accolades.

fnvoornaamst() {
laten naam = "Alice";
laten leeftijd = 25;
laten bericht = formaat!("Mijn naam is {} en ik ben {} jaar oud.", naam leeftijd);
println!("{}", bericht);
}

De naam variabele bevat een string, en de leeftijd variabele bevat een geheel getal. De bericht variabele heeft een opgemaakte tekenreeks die gebruikmaakt van formaat! om de tijdelijke aanduidingen te vervangen door overeenkomstige waarden, resulterend in een opmaaktekenreeks die de naam En leeftijd.

De formaat! macro ondersteunt verschillende formaatspecificaties waarmee u de uitvoer kunt regelen.

Hier leest u hoe u het aantal decimalen voor getallen met drijvende komma specificeert, de breedte van velden definieert en de uitvoer uitlijnt.

fnvoornaamst() {
laten pi = 3.14159;
laten geformatteerde_pi = formaat!("De waarde van pi is ongeveer {:.2}", pi);
println!("{}", geformatteerde_pi); // drukt 3.14 af
}

De pi variabele bevat een drijvende-kommawaarde; met de formaatspecificatie :.2, kunt u de opdracht geven formaat! macro weer te geven pi met twee decimalen.

De formaat! macro is een van de vele methoden voor het formatteren van tekenreeksen met Rust. Overweeg, afhankelijk van uw wensen, om de println! of schrijven! macro voor geformatteerde uitvoer naar de console of andere uitvoerstromen.

Numerieke waarden opmaken

Rust biedt ook functionaliteit voor het formatteren van verschillende numerieke waarden, van gehele getallen tot floats en andere numerieke typen.

Over het algemeen vormen formaatspecificaties de basis van tekenreeksopmaak in Rust, en je hebt de juiste specificatie nodig, afhankelijk van de numerieke waarde die je wilt formatteren.

Hier zijn enkele van de formaatspecificaties die Rust biedt voor numerieke waarden:

Bovendien kunt u opvulling en uitlijning opgeven voor numerieke waarden. De opvulling voegt spaties of nullen toe aan een opgemaakte numerieke waarde om de gewenste breedte te bereiken. Opvulling helpt bij het uitlijnen van waarden voor presentatie in tabelvorm of andere visueel georganiseerde lay-outs. Vóór de breedtewaarde kunt u het opvulteken specificeren, een spatie of nul.

Gebruik de om een ​​waarde links uit te lijnen - vlag. Om een ​​waarde rechts uit te lijnen, laat u de vlag weg of gebruikt u de '0'-vlag voor nulopvulling.

fnvoornaamst() {
 nummer = 42
 opgemaakt_nummer = "%10d" % nummer
 afdrukken (geformatteerd_nummer)
}

De waarde wordt rechts uitgelijnd binnen een breedte van 10 tekens, wat resulteert in acht voorloopspaties voor het nummer.

Aangepaste tekenreeksopmaak in roest

Aangepaste tekenreeksopmaak is belangrijk voor meer veeleisende bewerkingen. U kunt aangepaste opmaakimplementaties voor uw typen maken met Rust's ingebouwde standaard:: fmt moduul.

De standaard:: fmt module biedt eigenschappen voor het formatteren van uitvoer met een breed scala aan opties voor het aanpassen van de weergave van gegevens tijdens het tekenreeksconversieproces. De standaard:: fmt module biedt een Weergave En Debuggen eigenschap die handig is voor tekenreeksopmaakbewerkingen.

De weergave-eigenschap

De Weergave eigenschap helpt bij het produceren van voor mensen leesbare uitvoer door te definiëren hoe een object moet worden opgemaakt met de {} tijdelijke aanduiding in een string. Je kunt de Weergave eigenschap voor jouw aangepaste soorten door een methode te definiëren genaamd fmt dat neemt een formatter als argument.

De formatter biedt verschillende methoden om de uitvoer van het formaat te regelen, zoals de schrijf_str En schrijf_fmt methoden.

gebruik standaard:: fmt;
// Definieer een structuur met de naam `Point`
structuurPunt {
 X: i32,
 j: i32,
}
// Implementeer de eigenschap `Weergeven` voor `Punt`
impl fmt:: weergeven voor Punt {
fnfmt(&zelf, F: &muts fmt:: Formatter<'_>) -> fmt::Resultaat {
// Formatteer de `Point`-structuur als "(x, y)"
schrijven!(F, "({}, {})", zelf.X, zelf.y)
 }
}
fnvoornaamst() {
// Maak een nieuwe `Point`-instantie aan
laten punt = Punt {x: 5, j: 10 };
// Druk de `Point`-structuur af met behulp van de `Display`-opmaak
println!("Het punt is: {}", punt);
}

De Punt struct implementeert de Weergave karaktereigenschap. Binnen in de fmt methode, de schrijven! macro-indelingen en schrijf de gewenste uitvoer naar de formatter met de {} tijdelijke aanduiding.

De foutopsporingseigenschap

De Debuggen eigenschap is vergelijkbaar met de Weergave eigenschap, behalve dat het zich richt op het produceren van uitvoer die geschikt is voor foutopsporing en foutafhandeling doeleinden. De Debuggen eigenschap wordt voornamelijk gebruikt met de {:?} tijdelijke aanduiding.

Implementeren van de Debuggen eigenschap op uw aangepaste typen is eenvoudig. De Debuggen trait biedt een standaardimplementatie op basis van de Weergave karaktereigenschap. U kunt het standaardgedrag echter overschrijven om een ​​gespecialiseerde weergave van foutopsporing te bieden.

gebruik standaard:: fmt;
// Definieer een structuur met de naam `Persoon`
#[afleiden (Debug)]
structuurPersoon {
 naam: Snaar,
 leeftijd: u32,
}
// Implementeer de eigenschap `Weergeven` voor `Persoon`
impl fmt:: weergeven voor Persoon {
fnfmt(&zelf, F: &muts fmt:: Formatter) -> fmt::Resultaat {
// Formatteer de `Person`-structuur als een door mensen leesbare string
schrijven!(F, "Naam leeftijd: {}", zelf.naam, zelf.leeftijd)
 }
}
fnvoornaamst() {
// Maak een nieuwe `Person`-instantie aan
laten persoon = Persoon {
 naam: Snaar::van("Alice"),
 leeftijd: 30,
 };
// Druk de `Person`-structuur af met behulp van de `Display`-opmaak
println!("Weergave: {}", persoon);
// Druk de `Person`-structuur af met behulp van de `Debug`-opmaak
println!("Foutopsporing: {:?}", persoon);
}

Het programma leidt de Debuggen eigenschap voor de Persoon structureren met #[afleiden (Debug)]. Dit genereert automatisch de implementatie op basis van de struct-velden.

De println-macro drukt de foutopsporingsrepresentatie af met de Debuggen opmaak tijdelijke aanduiding voor het opmaken van de uitvoer met behulp van de Debuggen implementatie.

Roest heeft een functierijk typesysteem

Het rijke type-systeem van Rust speelt een cruciale rol bij het formatteren van tekenreeksen. Door gebruik te maken van de statische typen en krachtige opmaakbibliotheken van Rust, kunt u veilige, efficiënte code schrijven terwijl u tekenreeksmanipulatie en opmaaktaken uitvoert.

Het typesysteem zorgt voor veiligheid tijdens het compileren en voorkomt veelvoorkomende fouten, van niet-overeenkomende typen tot problemen met formaatspecificaties. Met de combinatie van het typesysteem van Rust en zijn uitgebreide opmaakmogelijkheden, kan dat ga zelfverzekerd om met stringopmaakuitdagingen en profiteer van de prestaties en veiligheid van de taal garanties.