Question

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

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!(),
    }
}

如何将结构中的String与常量值匹配？

2 个答案: