生锈 – 在反序列化时是否有更简单的方法来转换类型?

使用serde_json,我有带有字符串的JSON对象,我需要转换为浮点数.我偶然发现了一个自定义解串器解决方案,但它似乎是一个黑客攻击. Here is a working playground example of the code below.

#[macro_use]
extern crate serde_derive;
extern crate serde;
extern crate serde_json;

use serde_json::Error;
use serde::de::{Deserialize, DeserializeOwned, Deserializer};

#[derive(Serialize, Deserialize)]
struct Example {
    #[serde(deserialize_with = "coercible")]
    first: f64,
    second: f64,
}

fn coercible<'de, T, D>(deserializer: D) -> Result<T, D::Error>
where
    T: DeserializeOwned,
    D: Deserializer<'de>,
{
    use serde::de::Error;
    let j = String::deserialize(deserializer)?;
    serde_json::from_str(&j).map_err(Error::custom)
}

fn typed_example() -> Result<(), Error> {
    let data = r#"["3.141",1.618]"#;
    let e: Example = serde_json::from_str(data)?;
    println!("{} {}", e.first * 2.0, e.second * 2.0);
    Ok(())
}

fn main() {
    typed_example().unwrap();
}

上面的代码按照您的预期编译和运行,输出两个浮点数.

我正在努力学习解串器解决方案的工作原理,但我想知道我是朝着正确的方向前进,还是有更好的方法来做到这一点.

最佳答案
使用强制性工作的意外.有了它,输入“3.141”被剥去了它的“s”,所以我有3.141被送入serde_json :: from_str(& j),它适当地返回了一个浮点数.例如,当输入JSON包含意外值时,这种意外解决方案容易且容易混淆.

我阅读了Serde文档(一个很棒的学习练习),并提出了在JSON(working playground here)反序列化时将字符串转换为f64的适当方法:

#[macro_use]
extern crate serde_derive;
extern crate serde;
extern crate serde_json;

use std::fmt;
use serde_json::Error;
use serde::de::{self, Deserializer, Unexpected, Visitor};

#[derive(Serialize, Deserialize)]
struct Example {
    #[serde(deserialize_with = "string_as_f64")]
    first: f64,
    second: f64,
}

fn string_as_f64<'de, D>(deserializer: D) -> Result<f64, D::Error>
where
    D: Deserializer<'de>,
{
    deserializer.deserialize_f64(F64Visitor)
}

struct F64Visitor;
impl<'de> Visitor<'de> for F64Visitor {
    type Value = f64;
    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("a string representation of a f64")
    }
    fn visit_str<E>(self, value: &str) -> Result<f64, E>
    where
        E: de::Error,
    {
        value.parse::<f64>().map_err(|_err| {
            E::invalid_value(Unexpected::Str(value), &"a string representation of a f64")
        })
    }
}

fn typed_example() -> Result<(), Error> {
    let data = r#"["3.141",1.618]"#;
    let e: Example = serde_json::from_str(data)?;
    println!("{} {}", e.first * 2.0, e.second * 2.0);
    Ok(())
}

fn main() {
    typed_example().unwrap();
}

感谢Serde开发者,因为尽管Serde documentation看起来对我的眼睛来说完全是钝的,但事实证明它非常有用且易于理解.我只需要从顶部开始并慢慢阅读.

转载注明原文:生锈 – 在反序列化时是否有更简单的方法来转换类型? - 代码日志