Conversiones de campo personalizadas en Rust

serialize_with y deserialize_with le entregan un campo a tu propia función.

use serde::{Deserialize, Deserializer, Serialize, Serializer};

#[derive(Debug, Serialize, Deserialize)]
struct Reading {
    sensor: String,
    #[serde(with = "millis")]
    elapsed: f64,
}

mod millis {
    use super::*;

    pub fn serialize<S: Serializer>(v: &f64, s: S) -> Result<S::Ok, S::Error> {
        s.serialize_u64((v * 1000.0).round() as u64)
    }

    pub fn deserialize<'de, D>(d: D) -> Result<f64, D::Error>
    where
        D: Deserializer<'de>,
    {
        let ms = u64::deserialize(d)?;
        Ok(ms as f64 / 1000.0)
    }
}

fn main() -> Result<(), serde_json::Error> {
    let r = Reading { sensor: "clock".to_string(), elapsed: 1.25 };
    let json = serde_json::to_string(&r)?;
    println!("{json}");
    println!("{:?}", serde_json::from_str::<Reading>(&json)?);
    Ok(())
}

Cómo funciona

with fija ambas direcciones de una vez para un campo.
Las funciones toman un serializador o un deserializador.
Úsalo para timestamps, unidades y codificaciones heredadas.

Palabras clave y builtins usados aquí

Ok
Result
String
as
f64
fn
let
mod
pub
struct
super
u64
use
where

El intento, en números

Líneas: 32
Caracteres a escribir: 715
Tokens: 227
Ritmo de tres estrellas: 110 tpm

Al ritmo de tres estrellas de 110 tokens por minuto, este intento toma unos 124 segundos.

Escribe este fragmento

Paso 1 de 2 en Personalización y fallos; paso 9 de 11 en Serde y JSON.

← Anterior Siguiente →