主页 / coding / 问题 / 77991618
Accepted
kyleqian
Asked: 2024-02-14 08:48:47 +0800 CST

有没有更好的方法从 HashMap 的条目初始化结构？

  • 772

我有一个 PostgreSQL 连接信息的结构：

struct PgConf {
    host: String,
    port: i16,
    user: String,
    passwd: String,
    dbname: String
}

现在我必须从 HashMap<String, String> 初始化它：

impl PgConf {
    fn init(&mut self, args: &ArgList) -> () {
        if let Some(val) = args.get("host") {
            self.host = val.clone();
        }
        if let Some(val) = args.get("port") {
            self.port = val.parse().unwrap_or(5432);
        }
        if let Some(val) = args.get("user") {
            self.user = val.clone();
        }
        if let Some(val) = args.get("passwd") {
            self.passwd = val.clone();
        }
        if let Some(val) = args.get("db") {
            self.dbname = val.clone();
        }
    }
}

我觉得上面的代码有点臃肿。有更好的方法来实现这一目标吗？

rust

2 个回答

  1. Best Answer

    更好的编写方法是创建一个返回的函数Option<PgConf>

    fn try_create(args: HashMap<String,String>) -> Option<PgConfig>{
   let host = args.get("host")?;
   let user = args.get("user")?;
   let port = args.get("port")?.parse().unwrap_or(5432);
   let passwd = args.get("passwd")?;
   let dbname = args.get("db")?;
   Some(PgConfig{host,port,user,passwd,dbname})
}

    如果哈希图中并非所有字段都存在，则将?返回None。当它们全部存在时，将创建一个封装在Some

    或者类似的东西。

    • 1

  2. 如果您想要一个很好的替代方案，您可以通过类型擦除的 serde 实现（例如 serde_json）进行往返，那么这只是一个问题：

    fn convert(h: HashMap<String, String>) -> Option<PgConf> {
    serde_json::to_value(h).ok()
        .and_then(|v| PgConf::deserialize(v).ok())
}

    尽管这需要一些支持，但注释结构以开头：

    #[derive(Deserialize)]
struct PgConf {
    host: String,
    #[serde(
        default = "default_port",
        deserialize_with = "deserialize_number_from_string"
    )]
    port: u16,
    user: String,
    passwd: String,
    dbname: String,
}

    然后实现相关的钩子以获得端口上所需的处理：

    fn default_port() -> u16 {
    5432
}
/// copied from serde_aux as the playground doesn't have it
pub fn deserialize_number_from_string<'de, T, D>(deserializer: D) -> Result<T, D::Error>
where
    D: Deserializer<'de>,
    T: FromStr + serde::Deserialize<'de>,
    <T as FromStr>::Err: Display,
{
    #[derive(Deserialize)]
    #[serde(untagged)]
    enum StringOrInt<T> {
        String(String),
        Number(T),
    }

    match StringOrInt::<T>::deserialize(deserializer)? {
        StringOrInt::String(s) => s.parse::<T>().map_err(serde::de::Error::custom),
        StringOrInt::Number(i) => Ok(i),
    }
}

    在某些情况下，这是有意义的，大多数情况下，您已经对该结构使用 serde，因此所有“支持”部分都已经存在，您只需要利用它即可。否则它不会推荐它，因为它应该低于理想的效率，但这是当它们确实适用时你很高兴想到的事情之一。

    • 0

相关问题