Rust中如何从自定义类型构建对象？属性匹配与赋值求助

我正在Rust中编写一个子例程，用来把表示对象属性及其值的自定义数据类型转换成对应对象，但不知道怎么实现。
我的需求是从用户输入创建对象，计划先把输入解析为自定义的Value枚举类型，再转换成目标Spell对象。
现在遇到的问题是：遍历这个自定义数据类型时，没法判断字符串对应的属性是不是对象的真实属性，也不知道怎么给该属性赋值。

目前的代码实现如下：

enum Value {
    String(String),
    Float(f64),
    Boolean(bool),
    Object(String, Vec<(String, Value)>),
} // Vec<(String, Value)> 示例: ["Kind", Object("Particle", [("energy", 4.3), ("shape", Object("Sphere", [("radius", 3.2)]))])]


fn create_spell(properties: Vec<(String, Value)>) -> Spell {
    let mut spell = Spell::new();

    fn create_spell_inner(properties: Vec<(String, Value)>, spell: &mut Spell) {
        for property in properties{
            match property {
                // String = 当前对象的属性名
                // Value = 当前对象的属性值
                
            }
        }
    }
    return spell;
}

create_spell函数接收自定义数据类型并返回Spell对象，这是预期功能。

1. 匹配属性名并赋值 #

针对Spell的已知属性，直接在match分支中匹配属性名字符串，根据Value的变体类型完成赋值。比如假设Spell有name: String、power: f64、enabled: bool这些字段：

2. 处理嵌套对象 #

如果属性值是Object类型，需要额外编写对应的构造函数（比如create_particle、create_sphere）来处理嵌套对象的转换，再将结果赋值给Spell的对应字段。

3. 处理未知属性 #

可以添加默认分支，忽略未知属性或者输出警告，避免程序崩溃。

修改后的代码示例：

// 假设的Spell结构体定义（根据实际情况调整）
struct Spell {
    name: String,
    power: f64,
    enabled: bool,
    particle: Option<Particle>,
}

struct Particle {
    energy: f64,
    shape: Option<Sphere>,
}

struct Sphere {
    radius: f64,
}

impl Spell {
    fn new() -> Self {
        Self {
            name: String::new(),
            power: 0.0,
            enabled: false,
            particle: None,
        }
    }
}

enum Value {
    String(String),
    Float(f64),
    Boolean(bool),
    Object(String, Vec<(String, Value)>),
}

fn create_sphere(properties: Vec<(String, Value)>) -> Sphere {
    let mut sphere = Sphere { radius: 0.0 };
    for (key, val) in properties {
        match key.as_str() {
            "radius" => {
                if let Value::Float(r) = val {
                    sphere.radius = r;
                }
            }
            _ => {} // 忽略未知属性
        }
    }
    sphere
}

fn create_particle(properties: Vec<(String, Value)>) -> Particle {
    let mut particle = Particle { energy: 0.0, shape: None };
    for (key, val) in properties {
        match key.as_str() {
            "energy" => {
                if let Value::Float(e) = val {
                    particle.energy = e;
                }
            }
            "shape" => {
                if let Value::Object(_, props) = val {
                    particle.shape = Some(create_sphere(props));
                }
            }
            _ => {} // 忽略未知属性
        }
    }
    particle
}

fn create_spell(properties: Vec<(String, Value)>) -> Spell {
    let mut spell = Spell::new();

    fn create_spell_inner(properties: Vec<(String, Value)>, spell: &mut Spell) {
        for (key, val) in properties {
            match key.as_str() {
                "name" => {
                    if let Value::String(n) = val {
                        spell.name = n;
                    }
                }
                "power" => {
                    if let Value::Float(p) = val {
                        spell.power = p;
                    }
                }
                "enabled" => {
                    if let Value::Boolean(e) = val {
                        spell.enabled = e;
                    }
                }
                "particle" => {
                    if let Value::Object(_, props) = val {
                        spell.particle = Some(create_particle(props));
                    }
                }
                _ => {
                    // 可选：打印警告提示未知属性
                    eprintln!("未知属性: {}", key);
                }
            }
        }
    }

    create_spell_inner(properties, &mut spell);
    spell
}

关键说明 #

• 针对每个目标结构体（Spell/Particle/Sphere）编写对应的构造函数，负责处理各自的属性转换。
• 通过匹配属性名字符串，确保只处理对象的真实属性，避免无效赋值。
• 嵌套对象通过递归调用对应构造函数完成转换，保持代码逻辑清晰。
• 未知属性可以选择忽略或抛出提示，提升代码健壮性。

内容的提问来源于stack exchange，提问作者CocytusDEDI