ЈСОН серијализација и десериализација са Руст-ом

ЈСОН (ЈаваСцрипт Објецт Нотатион) се појавио као популаран формат за размену података у софтверу развој због своје једноставности, читљивости и широке подршке у различитим програмима језика. ЈСОН је лагана алтернатива КСМЛ-у за пренос података између сервера и веб апликације или између различитих компоненти софтверског система.

Један од кључних аспеката рада са ЈСОН-ом је процес серијализације и десериализације који омогућава вам да конвертујете ЈСОН податке у структурирани формат којим можете лако да манипулишете у оквиру свог програме. У већини случајева, ако желите да радите са ЈСОН-ом на другим језицима, можда ћете морати да серијалујете и десериализујете ЈСОН податке у уграђене структуре података језика.

Почетак рада са Сердеом

Серде (серијализација и десериализација) је широко коришћена Руст библиотека која обезбеђује оквир за конверзију Руст структуре података у формате за складиштење, пренос, дељење и друге.

Серде омогућава беспрекорну конверзију између Руст типова података и различитих формата за размену података, укључујући ЈСОН, ИАМЛ, БСОН, ЦБОР, МессагеПацк и друге.

Примарни фокус Сердеа је да процес серијализације и десеријализације буде што једноставнији и ефикаснији уз одржавање јаких карактеристика куцања и безбедности.

Додајте ове директиве у зависности одељак вашег Царго.томл датотеку за инсталацију и употребу Серде као зависност од треће стране са Царго-ом.

[зависности]
серде = {верзија = "1.0.159", карактеристике = ["извести"] }
серде_јсон = "1.0.96"

Требаће вам оба серде и серде_јсон сандуке за интеракцију са ЈСОН-ом. Тхе серде сандук пружа основне функције, и серде_јсон сандук је специфична имплементација Серде-а за рад са ЈСОН-ом.

Ево како можете да увезете серде_јсон сандук и Сериализе и Десериализе модули из серде сандук:

користити серде::{Сериализе, Десериализе};
користити серде_јсон;

Све у свему, Серде је моћан алат који ће вам требати у вашем развојном арсеналу ако радите са ЈСОН-ом у Русту.

Серијализација података са Серде

Процес ЈСОН серијализације подразумева претварање типа Руст (прилагођеног или уграђеног) у ЈСОН за друге операције. Серде пружа скуп атрибута које можете користити са Руст структуром да бисте омогућили прецизну контролу над процесом серијализације, укључујући #[дериве (сериализе)] атрибут који вам омогућава да генеришете серијализациони код за своје структуре података и конвертујете Руст структуру у ЈСОН.

Размотрите ову структуру која представља биолошке податке особе; ево како можете да увезете и користите Сериализе атрибут на структури:

користити серде::{Сериализе, Десериализе};
користити серде_јсон;
#[дериве (сериализе)]
струцтОсоба {
 име: Низ,
 старост: у32,
}

Анотацијом на Особа струцт витх тхе [#дериве (сериализе)], кажете Сердеу да генерише неопходан серијализациони код за Особа струцт аутоматски.

Ево како можете серијализирати инстанцу Особа струцт у ЈСОН:

користити серде::{Сериализе};
користити серде_јсон;
фнглавни() {
// декларација инстанце структуре Персон са пољима имена и старости
дозволити особа = Особа {
 име: "Цхуквуемериво".то_стринг(),
 старост: 28,
 };
// серијализује структуру особе у ЈСОН користећи библиотеку серде_јсон
дозволити јсон = серде_јсон:: то_стринг(&персон).очекујте(„Серијализација није успела“);
// штампа серијализовани ЈСОН стринг
принтлн!(„Серијализовани ЈСОН: {}“, јсон);
}

У главни функција, тхе серде_јсон сандук серијализује особа објекат. Тхе то_стринг функција узима референцу на особа објекат и враћа ЈСОН стринг који представља серијализоване податке.

Коначно, главни функција штампа серијализовани ЈСОН на конзоли.

Тхе серде и серде_јсон су разноврсни, такође можете серијализирати низове помоћу серде.

користити серде::{Сериализе, Десериализе};
користити серде_јсон;
#[дериве (сериализе)]
струцтКоординате {
 Икс: ф32,
 и: ф32,
}
фнглавни() {
дозволити бодова = вец![ 
 Координате { к: 1.0, и: 2.0 },
 Координате { к: 3.5, и: 4.5 },
 ];
дозволити јсон = серде_јсон:: то_стринг(&поинтс).очекујте(„Серијализација није успела“); 
принтлн!(„Серијализовани ЈСОН: {}“, јсон); // Штампа серијализовани ЈСОН стринг
}

Тхе бодова променљива је вектор од Координате структуре које представљају тачке на равни. Примена Сериализе атрибут на Координате струцт вам омогућава да без напора серијализује вектор у ЈСОН.

Поред тога, можете серијализирати енуме у ЈСОН помоћу серде као што серијализујете структуре и вектори.

користити серде::{Сериализе, Десериализе};
користити серде_јсон;
#[дериве (Сериализе, Десериализе)]
енумАнимал {
 Пас(Низ),
 мачка (у32),
 птица,
}
фнглавни() {
дозволити пас = Животиња:: Пас("Русти".то_стринг());
дозволити јсон = серде_јсон:: то_стринг(&дог).очекујте(„Серијализација није успела“);
принтлн!(„Серијализовани ЈСОН: {}“, јсон);
}

У зависности од варијанте, процес серијализације се прилагођава (у овом случају, Животиња:: Пас варијанта укључује а Низ поље које ће Серде серијализирати као ЈСОН стринг).

Десериализација података са Серде

ЈСОН десериализација је процес трансформације ЈСОН података у изворне типове података програмског језика. Серде пружа свеобухватан оквир за ЈСОН десериализацију који ради на већини уграђених типова података.

Слично серијализацији, Серде нуди атрибуте које можете користити за означавање ваших Руст структура за процес десериализације. Два најчешће коришћена атрибута за серијализацију су #[дериве (десериализе)] и #[серде (преименуј = "јсон_фиелд_наме")] атрибути.

Тхе #[дериве (десериализе)] атрибут аутоматски изводи имплементацију десериализације за ваш Типови рђавих структура, док #[серде (преименуј = "јсон_фиелд_наме")] атрибут вам омогућава да мапирате поља структуре у одговарајућа имена ЈСОН поља.

Ево како можете да десериализујете ЈСОН податке у прилагођени тип структуре помоћу Серде:

користити серде:: Десериализе;
користити серде_јсон;
// дефинише структуру за особу са особином Десериализе из Серде
#[дериве (десериализе)]
струцтОсоба {
#[серде (преименуј = "име")]// преименује поље у "име" 
 пуно име: Низ, 
 старост: у32,
}
фнглавни() {
дозволити јсон_дата = р#"
 {
"име": "Н.Н. лице",
"старост": 30
 }
"#;
// десеријализује ЈСОН податке у структуру Персон 
дозволити особа: Особа = серде_јсон:: фром_стр (јсон_дата).унврап();
// Штампајте пуно име и старост особе
принтлн!(„Име: {}“, персон.фулл_наме);
принтлн!(„Старост: {}“, персон.аге);
}

Анотацијом на Особа струцт витх тхе #[дериве (десериализе)] атрибута, указујете да Серде може десериализовати структуру из ЈСОН-а. Тхе #[серде (преименуј = "име")] атрибут мапе тхе име поље у ЈСОН-у на пуно име поље.

Тхе фром_стр функција десеријализује јсон_дата променљива у особа објекат, и главни функција штампа поља на конзоли.

Серде подржава десериализацију на различитим Руст типовима података, укључујући примитивне типове, енуме, угнежђене структуре и колекције.

Ево како можете да десериализујете ЈСОН низ у Руст структуру која садржи векторско поље:

користити серде:: Десериализе;
#[дериве (десериализе)]
струцтПодаци {
 бројеви: Вец<у32>,
}
фнглавни() {
дозволити јсон_дата = р#"
 {
"бројеви": [1, 2, 3, 4, 5]
 }
"#;
дозволити подаци: Подаци = серде_јсон:: фром_стр (јсон_дата).унврап();
за број ин дата.нумберс {
принтлн!("Број: {}", број);
 }
}

Тхе главни функција десеријализује јсон_дата ЈСОН садржај у података променљива, а петља штампа елементе у вектору.

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

Серде ради са популарним Руст веб оквирима

Серде је моћна библиотека са много функција и једноставним АПИ-јем за серијализацију и десеријализацију података у различите формате.

Серде је широко прихваћен у Руст екосистему, а многи популарни сандуци и оквири имају уграђене подршка за Серде, укључујући популарне веб оквире као што су Ацтик, Варп и Роцкет и ОРМ-ове базе података као што су Диесел.