“永远不会读取值”警告似乎不正确。我应该忽略它吗？

Question

我用 Rust 编程才几个月。话虽这么说，我遇到了一条警告，内容如下：

warning: value assigned to `amount` is never read
   --> src\execute_action_functions.rs:428:21
    |
428 |             let mut amount: Option<f64> = None;
    |                     ^^^^^^
    |
    = help: maybe it is overwritten before being read?

为了清楚起见并避免意外错过关键细节，整个函数如下：

pub async fn handle_all_gemini(prefix: &str, message: &str, shared_neural_network: Arc<Mutex<NeuralNetwork>>, divisor: &f64) {


    if prefix.contains("Gemini received") {
        if message.contains("heartbeat") {
            return;
        }
        else {
            let data: Result<Value, serde_json::Error> = serde_json::from_str(message);

            let mut amount: Option<f64> = None;
            let mut price: Option<f64> = None;

            match data {
                Ok(value) => {
                    if value.get("socket_sequence")
                    .and_then(Value::as_i64) == Some(0) {
                        println!("Gemini: socket sequence is 0, ignoring...");
                        return;
                    }
                    if let Value::Object(map) = &value {
                        if let Some(Value::Array(events)) = map
                        .get("events") {
                            if let Some(Value::Object(event)) =
                             events.get(0) {
                                amount = event.get("amount")
                                    .and_then(|v| v.as_str())
                                    .and_then(|s| s.parse::<f64>().ok());
                                price = event.get("price")
                                    .and_then(|v| v.as_str())
                                    .and_then(|s| s.parse::<f64>().ok());
                            } 
                            else {
                                panic!("Gemini: event is not an object.
                                message: {}", message);
                            }
                        } 
                        else {
                            panic!("Gemini: events is not an array.
                            message: {}", message);
                        }
                    } 
                    else {
                        panic!("Gemini: Value is not an object.
                        message: {}", message);
                    }
                },
                Err(e) => {
                    panic!("Failed to parse JSON Gemini message\nError: {}
                    Message: {}", e, message);
                },
            }

            let new_values = [amount, price];
            let mut scaled_values: Vec<f64> = Vec::new();
            for value in &new_values {
                if let Some(val) = value {
                    scaled_values.push(val / divisor);
                } 
                else {
                    println!("One of the values was None");
                    panic!("amount: {:?}, price: {:?}", &amount, &price);
                }
            }
            if prefix.contains("sol") {
                let indices = [58, 59];
                let mut neural_network = 
                    shared_neural_network.lock().await;
                neural_network.update_input(&indices, &scaled_values)
                .await;
            }
            else if prefix.contains("xrp") {
                let indices = [92, 93];
                let mut neural_network = 
                    shared_neural_network.lock().await;
                neural_network.update_input(&indices, &scaled_values)
            .await;
            }
            else {
                panic!("This shouid never occur. Somehow prefix cointained phrase
                Gemini received but didn't contain the phrases XLM or XRP.
                prefix is: {}\nmessage: {}", prefix, message);
            }
        }
    }
    else {
        println!("Gemini: got a weird message: {}\nprefix:{}", message, prefix);
    }
}

正如您所看到的，如果我没有记错的话，至少在new_values初始化时肯定会读取它，并且在 for 循环中也会读取它。

我尝试将其更改为amount: Option<f64>;但是，我收到一个非常奇怪的警告：

warning: variable does not need to be mutable
   --> src\execute_action_functions.rs:429:17
    |
429 |             let mut price: Option<f64>;
    |                 ----^^^^^
    |                 |
    |                 help: remove this `mut`

这没有任何意义，因为我正在改变if let Value::Object(map) = &value { So 中的值，这使得它更加混乱。我不确定我做错了什么，因为我没有赋予它真正的值，所以不存在“读取前覆盖”问题，对吗？是不是跟有什么关系呢if let？任何帮助将不胜感激。

Answer 1

您首先在声明它的行中分配amount给：None

let mut amount: Option<f64> = None;

您稍后可以在此处重新分配 amount：

amount = event.get("amount")
    .and_then(|v| v.as_str())
    .and_then(|s| s.parse::<f64>().ok());

之后，您在这里阅读amount：

let new_values = [amount, price];

编译器实际上在这里非常聪明：代码中未到达第二个赋值的所有分支都会引发 a panic，导致它们永远无法到达后续读取。因此，编译器认为对 的初始赋值None是不必要的，因为该值永远不会被读取。您可以通过将该行更改为以下内容来修复此警告：

let amount: Option<f64>; //no initial value here

因为amount只分配一次（在读取之前），所以不必将其声明为可变的。

需要注意的是，这只是一个警告，而不是错误。您的程序仍然可以编译并正常工作，编译器只是告诉您它包含可能是无意的不必要的逻辑。