Kaip dirbti su TOML failais Rust

Konfigūracijos failai atlieka esminį vaidmenį kuriant programinę įrangą ir administruojant sistemą tinkinti ir koreguoti programinės įrangos elgseną, kad ją būtų galima pritaikyti skirtingoms aplinkoms ir vartotojui pirmenybės. Yra daugybė konfigūracijos failų tipų, pvz., YAML ir TOML.

TOML (Tom's Obvious Minimal Language) išsiskiria kaip galinga ir patogi parinktis tarp daugybės konfigūracijos failų formatų. sintaksė ir kaip ji pašalina esamų konfigūracijos failų formatų trūkumus, kad būtų intuityvesnis ir aiškesnis alternatyva.

TOML failo supratimas

Iš esmės TOML failo formatas išreiškia struktūrinius duomenis žmogui suprantamu formatu. TOML išsiskiria minimalistiniu ir intuityviu dizainu pagal rakto-reikšmių porą struktūra, kurioje kiekvienas raktas reiškia konfigūracijos parinktį, susietą su ją apibrėžiančia reikšme nustatymus.

TOML failo formatas remiasi paprastomis sintaksės taisyklėmis, teikiančiomis pirmenybę skaitomumui, todėl jis pasiekiamas žmonėms ir mašinoms. Viena svarbi TOML ypatybė yra įvairių duomenų tipų, įskaitant eilutes, sveikuosius skaičius, slankiojo kablelio skaičius, loginius, masyvus ir lenteles, palaikymas.

TOML universalumas leidžia lengvai išreikšti sudėtingas konfigūracijas, kad būtų galima pritaikyti įvairesnius naudojimo atvejus. TOML siūlo daugybę funkcijų ir funkcijų, todėl tai yra idealus pasirinkimas konfigūravimo tikslais.

1. Intuityvi struktūra: TOML naudoja hierarchinę struktūrą, kurią sudaro lentelės, raktų-reikšmių poros ir masyvai. TOML organizacija leidžia aiškiai ir logiškai pateikti sudėtingus konfigūracijos nustatymus.
2. Komentarai ir tarpai: TOML palaiko eilutinius ir kelių eilučių komentarus, leidžiančius efektyviai komentuoti ir dokumentuoti konfigūracijos failus. Tarpai yra ignoruojami, kad būtų užtikrintas skaitymas ir sumažintas nereikalingas triukšmas.
3. Stiprus spausdinimas: kiekviena TOML reikšmė yra susieta su konkrečiu duomenų tipu, nuo eilučių iki sveikųjų skaičių, slankiųjų, loginių ir datų. TOML griežtas įvedimo vykdymas padeda išlaikyti duomenų vientisumą, kad būtų galima apdoroti be klaidų.
4. Įdėtųjų struktūrų palaikymas: TOML palengvina lentelių įdėjimą lentelėse, kad būtų galima pateikti hierarchinę konfigūraciją. Įdėtos struktūros yra naudingos dirbant su kelių dimensijų nustatymais arba sudėtingomis taikomųjų programų sąrankomis.
5. Masyvo ir tiesioginės lentelės palaikymas: TOML pateikia masyvus ir eilutes lenteles, kad būtų galima lanksčiai išreikšti perteklines arba kompaktiškas duomenų struktūras.

TOML laikosi taisyklių ir susitarimų, apibrėžiančių jo sintaksę ir struktūrą. Formatas priklauso nuo įtraukos ir rakto-reikšmių porų, kad būtų pateikti konfigūracijos duomenys.

Štai paprasto TOML failo, skirto konfigūracijoms, pavyzdys:

[serveris]
uostas = 8080
šeimininkas = "vietinis šeimininkas"
derinti = klaidinga
[duomenų bazė]
vardas = "mano duomenų bazė"
Vartotojo vardas = "adminas"
Slaptažodis = "slaptas slaptažodis"

Šiame TOML faile yra du skyriai, kuriuose yra raktų ir reikšmių poros, atspindinčios konkrečias konfigūracijos parinktis. Čia, uostas įveskite [serveris] skyriuje nurodomas prievado numeris šeimininkas raktas, nurodantis serverio pagrindinio kompiuterio pavadinimą.

Darbas su TOML failais Rust

Rust, kalba, kuri didžiuojasi sauga, našumu ir kūrėjo patirtimi, pasirinko TOML failus kaip konfigūracijos formatą dėl sklandaus integravimo su savo etosu.

Rusto sprendimą naudoti TOML galite priskirti keletui pagrindinių veiksnių. Pirma, TOML sukuria harmoningą skaitomumo ir išraiškingumo pusiausvyrą. Be to, TOML minimalistinis požiūris užtikrina, kad jame nėra nereikalingo sudėtingumo, suderinant su Rust dizaino filosofija.

Yra keletas trečiųjų šalių dėžių, skirtų darbui su TOML failais Rust ekosistemoje, toml dėžė kaip pati populiariausia.

The toml „Crate“ teikia visapusišką TOML duomenų analizavimo, manipuliavimo ir nuoseklumo palaikymą, todėl tai yra nepakeičiamas įrankis tvarkant konfigūracijos failus ir struktūrinius duomenis „Rust“ programose.

Į dirbti su trečiųjų šalių paketais Rust, sukurkite Rust projektą su Cargo ir pridėkite šią direktyvą prie priklausomybės savo projekto skyrių Krovinys.toml failą, kurį norite įdiegti ir naudoti toml dėžė savo Rust projektuose:

[priklausomybės]
toml = "0.5"

Dėl TOML duomenų serializavimui ir deserializavimui, jums reikės serde dėžės. The toml dėžė puikiai sąveikauja su serde duomenų apdorojimui.

[priklausomybės]
serde = { versija = "1.0", funkcijos = ["išvesti"] }
toml = "0.5"

Kai pridėsite toml ir serde dėžes kaip priklausomybes, galite importuoti jas į savo Rust kodą ir naudoti jo funkcijas.

naudoti toml;

The toml crate gali skaityti, rašyti ir analizuoti TOML failus.

TOML failų skaitymas naudojant rūdis

Pridėjus toml crate kaip projekto priklausomybę ir importuodami dėžę į savo projektą, galite skaityti TOML failus savo Rust programose.

Pirmiausia turėsite atidaryti TOML failą su įtaisytuoju fs dėžės Failas struktūra:

naudoti std:: fs:: Failas;
naudoti std:: io:: Skaityti;
fnpagrindinis() {
leistimut failas = Failas:: atidaryti("config.toml".expect("Nepavyko atidaryti failo");
leistimut turinys = Styga::naujas();
 file.read_to_string(&mut turinys)
 .expect(„Nepavyko nuskaityti failo“);
// Šiuo metu „contents“ yra TOML failo turinys
println!("{}", turinys);
}

The pagrindinis atidaroma funkcija a krovinys.toml failą su Failas:: atidaryti metodą ir nuskaito failo turinį į eilutę su skaityti_ į eilutę metodas prieš spausdinant turinį į konsolę su println! makrokomandą.

TOML failo turinį skaityti kaip eilutę yra naudinga, tačiau daugeliu atvejų norite įkelti duomenis labiau struktūrizuotu formatu. Rūdys mums leidžia apibrėžti struktūrų tipus kurie atspindi mūsų TOML failų duomenų struktūrą. Dabar galite naudoti toml crate, kad TOML duomenys būtų automatiškai suskirstyti į šias struktūras.

Štai kaip galite perskaityti savo projekto turinį Krovinys.toml failą ir atsispausdinkite juos konsolėje:

naudoti serde:: Deserializuoti;
naudoti std:: fs;
#[išvesti (derinti, deserializuoti)]
struktūraCargoToml {
#[allow (dead_code)]// Išjungti perspėjimą apie mirusį kodą visai struktūrai
 pakuotė: pakuotė,
#[allow (dead_code)]
 priklausomybės: priklausomybės,
}
#[išvesti (derinti, deserializuoti)]
struktūraPaketas {
#[allow (dead_code)]
 vardas: Styga,
#[allow (dead_code)]
 versija: Styga,
#[allow (dead_code)]
 leidimas: Styga,
}
#[išvesti (derinti, deserializuoti)]
struktūraPriklausomybės {
#[allow (dead_code)]
 serde: SerdeDependency,
#[allow (dead_code)]
 toml: Styga,
}
#[išvesti (derinti, deserializuoti)]
struktūraSerdeDependency {
#[allow (dead_code)]
 versija: Styga,
#[allow (dead_code)]
 funkcijos: Sen<Styga>,
}
fnpagrindinis() {
leisti toml_str = fs:: read_to_string("Krovinys.toml".expect(„Nepavyko nuskaityti Cargo.toml failo“);
leisti cargo_toml: CargoToml = toml:: from_str(&toml_str).expect(„Nepavyko deserializuoti Cargo.toml“);
println!("{:#?}", cargo_toml);
}

The CargoToml, Paketas, Priklausomybės, ir SerdeDependency structs atspindi TOML failo struktūrą. Struktūros yra anotuotos su #[allow (dead_code)] atributus, kad išjungtų struktūrų įspėjimus apie mirusį kodą.

The pagrindinis funkcija nuskaito turinį Krovinys.toml failą į toml_str kintamasis ir from_str metodas toml crate nuskaito TOML eilutę ir deserializuoja turinį į cargo_toml kintamasis.

Štai paleidimo rezultatas pagrindinis funkcija:

Duomenų įrašymas į TOML failus naudojant rūdis

Duomenų rašymas į TOML failus yra patogus generuojant konfigūracijos failus iš savo programų.

Štai kaip suskirstyti struktūrą į TOML ir įrašyti turinį į a config.toml failą savo projekto šakniniame kataloge:

naudoti std:: fs:: Failas;
naudoti std:: io:: Rašyti;
naudoti serde:: Serializuoti;
naudoti toml:: to_string;
#[išvesti (serializuoti)]
struktūraServerio konfigūracija {
 šeimininkas: Styga,
 prievadas: u16,
 laikas baigėsi: u32,
}
fnwrite_config_to_file(config: &ServerConfig, failo_kelias: &g) -> RezultatasDėžė<dyn std:: klaida:: Klaida>> {
leisti toml_string = to_string (config)?;
leistimut file = Failas:: sukurti (failo_kelias)?;
 file.write_all (toml_string.as_bytes())?;
Gerai(())
}
fnpagrindinis() {
leisti config = ServerConfig {
 šeimininkas: "vietinis šeimininkas".to_owned(),
 prievadas: 8000,
 laikas baigėsi: 30,
 };
jeiguleistiErr(e) = write_config_to_file(&config, "config.toml") {
 eprintln!("Klaida: {}", e);
 } Kitas {
println!(„Sėkmingai sukurtas konfigūracijos failas“.);
 }
}

The write_config_to_file funkcija nurodo egzempliorių Serverio konfigūracija struct ir failo kelią config.toml failas konvertuoja struktūros egzempliorių į eilutę ir sukuria config.toml failą nurodytame failo kelyje. Galiausiai jis įrašo TOML eilutę į TOML failą naudodamas rašyti_viską funkcija.

The pagrindinis funkcija inicijuoja a Serverio konfigūracija struct objektą, iškviečia the write_config_to_file su reikalingais duomenimis ir išspausdina pranešimą į konsolę pagal operacijos būseną.

Krovinys priklausomybės valdymui naudoja TOML failus

„Cargo“, „Rust“ priklausomybių tvarkyklė ir kūrimo įrankis, naudokite TOML failus, kad nurodytumėte ir valdytumėte priklausomybes.

Kai kuriate naują Rust projektą su Cargo, jis sugeneruoja Cargo.toml failą jūsų projekto šakniniame kataloge, kuris naudojamas kaip jūsų projekto manifestas. Čia galite deklaruoti savo projekto metaduomenis, priklausomybes, kūrimo konfigūracijas ir kitus parametrus.