如何在Rust中索引结构体的不同类型字段

我是Rust新手，可能忽略了一些基础内容。我希望实现像struct_instance['field']这样的方式来索引结构体的任意字段，编写了如下代码：

use std::ops::Index;

enum Selection {
    Full,
    Partial,
}

struct Config {
    display: bool,
    timeout: u16,
    selection: Selection,
}

impl Index<&'_ str> for Config {
    type Output = bool;

    fn index(&self, index: &'_ str) -> &Self::Output {
        match index {
            "display" => &self.display,
            _ => panic!("Unknown field: {}", index),
        }
    }
}

fn main() {
    let config = Config {
        display: true,
        timeout: 500,
        selection: Selection::Partial,
    };

    let display = config["display"];

    println!("{display}");
}

问题在于：我无法找到索引结构体所有不同类型字段的方法，因为关联类型Output只能定义一种类型。我希望match能够处理Config的所有字段，请问有没有可行的办法？

方案1：用枚举统一字段类型 #

Index trait的Output必须是单一类型，所以可以先定义一个能容纳所有字段类型的枚举，让Output指向这个枚举：

use std::ops::Index;

enum Selection {
    Full,
    Partial,
}

// 定义可容纳所有Config字段类型的枚举
enum ConfigField<'a> {
    Bool(&'a bool),
    U16(&'a u16),
    Selection(&'a Selection),
}

struct Config {
    display: bool,
    timeout: u16,
    selection: Selection,
}

impl Index<&'_ str> for Config {
    type Output = ConfigField<'_>;

    fn index(&self, index: &'_ str) -> &Self::Output {
        match index {
            "display" => &ConfigField::Bool(&self.display),
            "timeout" => &ConfigField::U16(&self.timeout),
            "selection" => &ConfigField::Selection(&self.selection),
            _ => panic!("Unknown field: {}", index),
        }
    }
}

fn main() {
    let config = Config {
        display: true,
        timeout: 500,
        selection: Selection::Partial,
    };

    let display = &config["display"];
    match display {
        ConfigField::Bool(val) => println!("display: {}", val),
        _ => panic!("Unexpected type for display field"),
    }

    let timeout = &config["timeout"];
    match timeout {
        ConfigField::U16(val) => println!("timeout: {}", val),
        _ => panic!("Unexpected type for timeout field"),
    }
}

使用时需要通过模式匹配取出对应类型，虽然繁琐，但能满足动态索引所有字段的需求。

方案2：用宏生成类型安全的字段访问 #

可以编写宏来生成类似索引的访问逻辑，编译时确定返回类型，避免运行时类型匹配开销：

enum Selection {
    Full,
    Partial,
}

struct Config {
    display: bool,
    timeout: u16,
    selection: Selection,
}

impl Config {
    macro_rules! get_field {
        ($self:expr, $field:literal) => {
            match $field {
                "display" => &$self.display,
                "timeout" => &$self.timeout,
                "selection" => &$self.selection,
                _ => panic!("Unknown field: {}", $field),
            }
        };
    }
}

fn main() {
    let config = Config {
        display: true,
        timeout: 500,
        selection: Selection::Partial,
    };

    // 显式指定返回类型，宏会在编译时检查匹配
    let display: &bool = Config::get_field!(&config, "display");
    println!("display: {}", display);

    let timeout: &u16 = Config::get_field!(&config, "timeout");
    println!("timeout: {}", timeout);
}

方案3：借助序列化库实现动态访问 #

如果可以引入第三方库，比如serde和serde_json，可以将结构体序列化为JSON对象后通过键名访问：

use serde::Serialize;
use serde_json::Value;

#[derive(Serialize)]
enum Selection {
    Full,
    Partial,
}

#[derive(Serialize)]
struct Config {
    display: bool,
    timeout: u16,
    selection: Selection,
}

fn main() {
    let config = Config {
        display: true,
        timeout: 500,
        selection: Selection::Partial,
    };

    let config_json: Value = serde_json::to_value(&config).unwrap();
    let display = config_json["display"].as_bool().unwrap();
    let timeout = config_json["timeout"].as_u64().unwrap() as u16;
    
    println!("display: {}", display);
    println!("timeout: {}", timeout);
}

这种方式灵活但有序列化开销，适合对性能要求不高的场景。

内容的提问来源于stack exchange，提问作者Slava.In