let-rebinding和标准赋值之间有什么区别？

Question

在Rust中，为了改变可变变量的值，在下面的示例代码中，let x = 12和x = 12有什么区别？

fn main() {
    let mut x: i32 = 8;
    {
        println!("{}", x); 
        let x = 12;  // what if change to x = 12
        println!("{}", x); 
    }
    println!("{}", x); 
    let x =  42;
    println!("{}", x); 
}

输出结果是8, 12, 8, 42。 如果我将let x = 12更改为x = 12...

fn main() {
    let mut x: i32 = 8;
    {
        println!("{}", x); 
        x = 12; 
        println!("{}", x); 
    }
    println!("{}", x); 
    let x =  42;
    println!("{}", x); 
}

输出结果是8, 12, 12, 42。

我理解Rust使用let来进行变量绑定，因此let x = 12是一个变量重新绑定，且绑定只在作用域内有效。但是如何解释x = 12的功能及其相应的作用域？这是否是一种类型的变量绑定？

- enaJ

Answer 1

第二个let x引入了第二个绑定，遮蔽了第一个绑定，直到块结束。也就是说，有两个名为x的变量，但你只能在let x = 12;语句之后的块语句内部访问第二个变量。这两个变量不需要具有相同的类型！

然后，在块语句之后，第二个x超出了范围，因此您再次访问第一个x。

然而，如果您写成x = 12;，那么这是一个赋值表达式：将覆盖x中的值。这不会引入新的变量，因此所分配的值的类型必须与变量的类型兼容。

如果编写循环，则此差异很重要。例如，请考虑以下函数：

fn fibonacci(mut n: u32) -> u64 {
    if n == 0 {
        return 1;
    }

    let mut a = 1;
    let mut b = 1;

    loop {
        if n == 1 {
            return b;
        }

        let next = a + b;
        a = b;
        b = next;
        n -= 1;
    }
}

这个函数重新分配变量，以便循环的每次迭代可以操作前一次迭代分配的值。

但是，你可能会被诱惑像这样编写循环：

loop {
    if n == 1 {
        return b;
    }

    let (a, b) = (b, a + b);
    n -= 1;
}

这样做是行不通的，因为let语句会引入新的变量，而这些变量将在下一次迭代开始之前超出作用域。在下一次迭代中，(b, a + b)仍将使用原始值。

- Francis Gagné

---

嗨Francis，感謝你提供的意見。你能解釋一下x = 12的功能是什麼嗎？ - enaJ