如何匹配具有常量值的结构中的字符串？

Question

是否可以用静态 str 值匹配 Rust 结构中的 String？这是一个最小的例子：

struct SomeStruct {
    a: String,
}

fn main() {
    let s = SomeStruct {
        a: "Test".to_string(),
    };
    match s {
        SomeStruct { a: "Test" } => {
            println!("Match");
        }
    }
}

这不会编译，因为静态 str 引用无法与 String 成员匹配。它可以在不解构 a 然后在匹配中添加嵌套 if 语句的情况下工作吗？

Answer 1

目前无法在单一模式中执行此操作，但有朝一日可能会实现。现在，用模式和 match guard 替换模式可能是最简单的，就像这样：

match s {
    SomeStruct { ref a } if a == "Test" => {
        println!("Match");
    }
}

Answer 2

跳出框框思考一下，您可以创建一个具有 &str 而不是 String 的并行类型，并添加一个方法在它们之间进行转换：

struct SomeStruct {
    a: String,
}

impl SomeStruct {
    fn as_ref(&self) -> SomeStructRef {
        SomeStructRef { a: &self.a }
    }
}

struct SomeStructRef<'a> {
    a: &'a str,
}

fn main() {
    let s = SomeStruct {
        a: "Test".to_string(),
    };
    match s.as_ref() {
        SomeStructRef { a: "Test" } => {
            println!("Match");
        }
        _ => panic!(),
    }
}

然后您还可以为要匹配的值创建一个常量：

#[derive(PartialEq, Eq)]
struct SomeStructRef<'a> {
    a: &'a str,
}

const TEST_STRUCT: SomeStructRef = SomeStructRef { a: "Test" };

fn main() {
    let s = SomeStruct {
        a: "Test".to_string(),
    };
    match s.as_ref() {
        TEST_STRUCT => {
            println!("Match");
        }
        _ => panic!(),
    }
}

这里没有特定于结构的内容，相同的概念适用于枚举：

enum SomeEnum {
    One(String),
    Two(String),
}

impl SomeEnum {
    fn as_ref(&self) -> SomeEnumRef {
        match self {
            SomeEnum::One(v) => SomeEnumRef::One(v),
            SomeEnum::Two(v) => SomeEnumRef::Two(v),
        }
    }
}

enum SomeEnumRef<'a> {
    One(&'a str),
    Two(&'a str),
}

fn main() {
    let s = SomeEnum::Two("Test".to_string());
    match s.as_ref() {
        SomeEnumRef::Two("Test") => {
            println!("Match");
        }
        _ => panic!(),
    }
}

如何匹配具有常量值的结构中的字符串？

How do I match a String in a struct with a constant value?

pattern-matching

rust