Как работи форматирането на низове в Rust

Форматирането на низове е ключов аспект от програмирането, тъй като ви позволява да манипулирате и показвате данни по четим, структуриран начин. Можете да контролирате представянето на данни чрез форматиране на низове за по-добро потребителско изживяване.

Rust предоставя мощен и гъвкав механизъм за форматиране на низове, който ви позволява да създавате ясен и кратък изход, включително числени, дата, час и функционалност за обработка на грешки.

Основно форматиране на низове в Rust

Rust предоставя функционалност за форматиране на низове с други Вградени типове Rust.

Можете да използвате формат! макрос за основно форматиране на низ в Rust. The формат! macro предоставя кратък и мощен начин за конструиране на форматирани низове с контейнери, оградени във фигурни скоби.

fnосновен() {
позволявам име = "Алиса";
позволявам възраст = 25;
позволявам съобщение = формат!(„Казвам се {} и съм на {} години.“, име, възраст);
println!("{}", съобщение);
}

The име променливата съдържа низ и възраст променливата съдържа цяло число. The съобщение променливата има форматиран низ, който използва формат! за замяна на контейнерите със съответните стойности, което води до форматиращ низ, съдържащ име и възраст.

The формат! macro поддържа различни спецификатори на формати, които ви позволяват да контролирате изхода.

Ето как да посочите броя на десетичните знаци за числата с плаваща запетая, да дефинирате ширината на полетата и да подравните изхода.

fnосновен() {
позволявам pi = 3.14159;
позволявам formatted_pi = формат!(„Стойността на pi е приблизително {:.2}“, pi);
println!("{}", formatted_pi); // отпечатва 3.14
}

The пи променливата съдържа стойност с плаваща запетая; със спецификатора на формата :.2, можете да инструктирате формат! макрос за показване пи с два знака след десетичната запетая.

The формат! macro е един от многото методи за форматиране на низове с Rust. В зависимост от вашите изисквания, обмислете използването на println! или пиши! макрос за форматиран изход към конзолата или други изходни потоци.

Форматиране на числови стойности

Rust също предоставя функционалност за форматиране на различни числови стойности, от цели числа до плаващи числа и други числови типове.

Като цяло спецификаторите на формат са основата на форматирането на низове в Rust и ще ви трябва правилният спецификатор в зависимост от числената стойност, която искате да форматирате.

Ето някои от спецификаторите на формата, които Rust предоставя за числени стойности:

Освен това можете да зададете подпълване и подравняване за числови стойности. Подпълването добавя интервали или нули към форматирана цифрова стойност, за да се постигне желана ширина. Подпълването помага за подравняване на стойности за представяне в таблична форма или други визуално организирани оформления. Преди стойността на ширината можете да посочите знака за подпълване, интервал или нула.

За да подравните вляво стойност, използвайте - знаме. За да подравните стойност вдясно, пропуснете флага или използвайте флага '0' за нулева подложка.

fnосновен() {
 номер = 42
 форматирано_число = "%10d" % брой
 печат (форматирано_число)
}

Стойността е подравнена вдясно в рамките на ширина от 10 знака, което води до осем водещи интервала преди числото.

Персонализирано форматиране на низове в Rust

Персонализираното форматиране на низ е важно за по-взискателни операции. Можете да създадете персонализирани реализации на форматиране за вашите типове с вградения Rust std:: fmt модул.

The std:: fmt модулът предоставя черти за форматиране на изход с широка гама от опции за персонализиране на външния вид на данните по време на процеса на преобразуване на низове. The std:: fmt модул предоставя a Дисплей и Отстраняване на грешки характеристика, която е удобна за операции за форматиране на низове.

Характеристика на дисплея

The Дисплей trait помага за генериране на четим от човека изход, като дефинира как обектът трябва да бъде форматиран с {} контейнер в низ. Можете да приложите Дисплей черта за вашия потребителски типове чрез дефиниране на метод, наречен fmt който приема форматиране като аргумент.

Форматиращият предоставя различни методи за контролиране на изходния формат, като write_str и write_fmt методи.

използване std:: fmt;
// Дефиниране на структура с име `Точка`
структураТочка {
 х: i32,
 y: i32,
}
// Внедрете характеристиката `Display` за `Point`
импл fmt:: Дисплей за Точка {
fnfmt(&себе си, f: &мут fmt:: Formatter<'_>) -> fmt::Резултат {
// Форматиране на структурата `Point` като "(x, y)"
пиши!(е, "({}, {})", себе си.х, себе си.y)
 }
}
fnосновен() {
// Създайте нов екземпляр на `Point`
позволявам точка = точка { x: 5, y: 10 };
// Отпечатайте структурата `Point`, като използвате форматирането `Display`
println!("Въпросът е: {}", точка);
}

The Точка struct изпълнява Дисплей Характерна черта. Вътре в fmt метод, на пиши! макро формати и запишете желания изход във формататора с {} контейнер.

Характеристиката за отстраняване на грешки

The Отстраняване на грешки черта е подобна на Дисплей черта, с изключение на това, че се фокусира върху генерирането на изход, подходящ за отстраняване на грешки и обработка на грешки цели. The Отстраняване на грешки черта се използва главно с {:?} контейнер.

Внедряване на Отстраняване на грешки характеристика на вашите персонализирани типове е ясна. The Отстраняване на грешки характеристика осигурява изпълнение по подразбиране въз основа на Дисплей Характерна черта. Можете обаче да замените поведението по подразбиране, за да предоставите специализирано представяне за отстраняване на грешки.

използване std:: fmt;
// Дефиниране на структура с име `Person`
#[извличане (отстраняване на грешки)]
структураЛице {
 име: низ,
 възраст: u32,
}
// Прилагане на чертата `Показване` за `Човек`
импл fmt:: Дисплей за Лице {
fnfmt(&себе си, f: &мут fmt:: Formatter) -> fmt::Резултат {
// Форматиране на структурата `Person` като четим от човека низ
пиши!(е, „Име: {}, възраст: {}“, себе си.име, себе си.възраст)
 }
}
fnосновен() {
// Създайте нов екземпляр на `Person`
позволявам човек = Лице {
 име: низ::от("Алиса"),
 възраст: 30,
 };
// Отпечатайте структурата `Person`, като използвате форматирането `Display`
println!(„Дисплей: {}“, лице);
// Отпечатайте структурата `Person`, като използвате форматирането `Debug`
println!(„Отстраняване на грешки: {:?}“, лице);
}

Програмата извлича Отстраняване на грешки черта за Лице структура с #[извличане (отстраняване на грешки)]. Това автоматично генерира имплементацията въз основа на структурните полета.

Макросът println отпечатва представянето за отстраняване на грешки с Отстраняване на грешки контейнер за форматиране за форматиране на изхода с помощта на Отстраняване на грешки изпълнение.

Rust има богата на функции тип система

Богатата система на Rust играе решаваща роля при форматирането на низове. Като използвате статичното писане и мощните библиотеки за форматиране на Rust, можете да пишете безопасен и ефективен код, докато се справяте със задачи за манипулиране на низове и форматиране.

Типовата система гарантира безопасност по време на компилиране и предотвратява често срещани грешки, от несъответствия на типове до проблеми със спецификатора на формат. С комбинацията от типовата система на Rust и нейните обширни възможности за форматиране, можете уверено се справя с предизвикателствата при форматирането на низове и се възползва от производителността и безопасността на езика гаранции.