Rust中如何初始化String类型数组？解决&str与[String]比较编译错误

Hey there! Let's tackle your two questions one by one—first the compile error, then how to set up String arrays correctly.

Why You're Seeing the Compile Error #

The error can't compare &str with [std::string::String] happens because your types don't line up:

• command is a &&str (a reference to a string literal from your commands array)
• request is a &[String] (a reference to a slice of String values)

Rust won't let you compare these directly because they're fundamentally different types. You need to adjust your code to compare like-for-like values.

Fixing the Comparison Logic #

Assuming you want to check if the first element of request matches any of your commands, here's a revised version of your code that works:

pub fn route(request: &[String]) {
    let commands = ["one thing", "another thing", "something else"];

    // First, make sure we have a command in the request to avoid index errors
    if let Some(request_command) = request.first() {
        let mut command_found = false;
        for &command in commands.iter() {
            // Compare the &str command to the String's underlying &str
            if command == request_command.as_str() {
                // Do your logic here for matching commands
                println!("Matched command: {}", command);
                command_found = true;
                break;
            }
        }

        if !command_found {
            // Handle unknown command (Rust uses panic! or Result instead of "throw")
            panic!("Unknown command received: {}", request_command);
        }
    } else {
        panic!("Received an empty request—no command provided!");
    }
}

If your goal is to compare the entire request slice (e.g., multiple words in the request match a full command), you could join the request into a single string first:

let full_request = request.join(" ");
for &command in commands.iter() {
    if command == full_request.as_str() {
        // Do something
    }
}

Initializing a String Array Instead of &str #

To create an array of String values (not string literals), you can convert each literal using one of these common methods:

Method 1: Use String::from #

let commands: [String; 3] = [
    String::from("one thing"),
    String::from("another thing"),
    String::from("something else"),
];

Method 2: Use to_string() #

let commands: [String; 3] = [
    "one thing".to_string(),
    "another thing".to_string(),
    "something else".to_string(),
];

Method 3: Use into() (implicit conversion) #

let commands: [String; 3] = [
    "one thing".into(),
    "another thing".into(),
    "something else".into(),
];

With a [String; 3] array, you can compare elements directly to String values from the request without needing as_str():

pub fn route(request: &[String]) {
    let commands: [String; 3] = [
        "one thing".to_string(),
        "another thing".to_string(),
        "something else".to_string(),
    ];

    if let Some(request_cmd) = request.first() {
        for command in commands.iter() {
            if command == request_cmd {
                println!("Matched command: {}", command);
                return;
            }
        }
        panic!("Unknown command: {}", request_cmd);
    } else {
        panic!("Empty request");
    }
}

A quick note: Rust arrays have fixed lengths. If you need a dynamic collection (e.g., adding/removing commands later), use a Vec<String> instead:

let commands: Vec<String> = vec![
    "one thing".to_string(),
    "another thing".to_string(),
];

内容的提问来源于stack exchange，提问作者Cassandra O'Connell