rust-course/basic/variable

[sunface]

https://course.rs/basic/variable.html

[darkestsirius]

这里容易误导新人，一开始是变量不可变避免运行时检查从而提高性能，，后面又说不可变丧失性能，这里其实是矛盾的，没有说清楚

[jeffacode]

不至于吧，写多了就会发现大部分情况下都是不可变变量，基本很少会要去变

[underwoodnoble]

是你没有理解清楚，这里考虑的是不同的情形，如果一个变量你不需要它可变，那么你定义为可变变两就会损失一定的性能，因为要做runtime检查。而如果一个变量你需要它可变，你却声明为不可变，那么你只能通过不断声明新的同名变量来模拟可变，这个时候就会降低代码性能。

[MrStrangeBao]

可以这样理解:
let a = 123; // 定义常量
a = 1234; // 不可以修改,报错
let a = 321;// 覆盖 之前定义的
let mut x = 1; // 定义变量
x = 2; // 可以修改不会报错

[lighterEB]

这是有定语的“选择可变还是不可变，更多的还是取决于你的使用场景” 认真读一下:)

[EverYeon]

它意思是说如果一个变量永远不会变，那它在编译时已经确定了，避免了运行时开销检查类型，但是如果一个变量有可能会变，但是你定义成不可变：let x = 100; 如果需要修改，你只能重新定义一次这个变量let x = 200;来覆盖之前的值，前后你初始化了2个值，所以耗性能，明明只用定义一次，反而定义了多次

[sunface]

这里容易误导新人，一开始是变量不可变避免运行时检查从而提高性能，，后面又说不可变丧失性能，这里其实是矛盾的，没有说清楚

确实，这里没有讲清楚，感谢建议 :)

[DeWjjj]

只说mut可以修改变量，应该明确写出mut只是可以修改，而不能修改类型。

[sunface]

在理～～建议收到

[trytew]

我不理解为什么有一些let语句后面是无法指定类型的，比如if let或者是 let a: impl Trait是无法实现的，我知道可以用特征对象实现，但是我就是不明白为什么会出现这种只能靠类型推导反而无法指定类型的情况，这会让我觉得很别扭

[zcjie1]

我不理解为什么有一些let语句后面是无法指定类型的，比如if let或者是 let a: impl Trait是无法实现的，我知道可以用特征对象实现，但是我就是不明白为什么会出现这种只能靠类型推导反而无法指定类型的情况，这会让我觉得很别扭

因为实现了Trait特征的类型大小是不确定的，而编译器不包容这种不确定性。特征对象实际上就是加了一层指针，用确定大小的指针指向不确定大小的Trait类型。

[trytew]

因为实现了Trait特征的类型大小是不确定的，而编译器不包容这种不确定性。特征对象实际上就是加了一层指针，用确定大小的指针指向不确定大小的Trait类型。

我明白你的意思了，谢谢。按你的意思来说一个指针指向的类型无法描述的时候就无法为变量指定类型，我在想是否还有其他情况是无法指定变量类型的，我刚接触这个语言还不清楚，等我代码量上来了之后我再思考一下

[digger-yu]

字符串类型的这一小节，建议替换一下
原文
// 字符串类型
let spaces = " ";
// usize数值类型
let spaces = spaces.len();
#####################
替换后更清楚一些

fn main () {
let spaces = " ";
// usize数值类型
let spaces:usize = spaces.len();
println!("空格总共有 {}个", spaces);
}

[sendking]

记录下此刻arm版mac，还无法使用“解构式赋值”。目前版本 Rust 1.56.0

[sunface]

m1 ? 更新到最新版本才行

[maolonglong]

好家伙，解构式赋值那块的 .. 第一眼看以为是真的省略号，结果是语法的一部分

[lonexw]

这里的示例不能这样处理，Vec 无法解构赋值给元组的

[lesonky]

js程序员，不仔细看，默认以为是 ... ，结果是 .. ，少一个点，有点难受啊

[wgl758]

let (aa, .., bb, _) = (1, 2, 3, 4);
println!("aa={},bb={}", aa, bb);

元组只能解构元组

[edisonLzy]

解构赋值和 ts 很像

[ZYKWLJ]

这就是rust

[keigu2008]

Struct { e, .. } = Struct { e: 5 };这个绑定怎么理解呢？

[maolonglong]

.. 表示忽略 0 或多个，_ 表示忽略一个

[stevenkitter]

这个变量还必须叫 e ，如果你有一个叫f的变量 还没法赋值了。。。

[ZYKWLJ]

后面会讲

[ztsweet]

let mut spaces = " "; spaces = spaces.len();
Compiling variables v0.1.0 (/home/fzt/rt/test_projects/variables) Finished dev [unoptimized + debuginfo] target(s) in 0.13s Runningtarget/debug/variablesspaces 1

• rust 版本是1.60时，没有报错啊

[ztsweet]

尴尬，我刚又运行了一下，也不通过了，也没能复现，

[wgl758]

明显的类型不匹配啊 .

[zombie110year]

let mut string = "Hello, world"; 的时候声明了一个类型为 &'static str 的变量 string，该类型虽然不由人工提供，但由编译器自动推导，而 string.len() 得到的是该字符串的长度，其类型为 usize，因此是不能赋值给 string 变量的。
但如果使用 let string = string.len();，该代码就能编译，因为是声明了一个新的 usize 类型（自动推导）的变量，其名称与之前类型为 &str 的变量相同，因为 Rust 遵守变量遮蔽规则，后声明的 string 会遮蔽住前面的 string。
但并不能认为 Rust 会允许变量存储不同类型的值。

[raotaohub]

let mut str = ' ' ; // 类型是string

str = str.len(); //  非string类型 赋值给 string类型 !!编译不通过 

str = '你好哦'; // ~~改成这样，则编译通过的

大概是这么回事

[ComeStart]

可能是运行前忘记按ctrl+s了:-P

[zhengtong0898]

不可变可以带来安全性，但是丧失了灵活性和性能。
而可变变量最大的好处就是使用上的灵活性和性能上的提升。

如果上面这段话表达没有问题，能否详细展开说明:

1. 为什么不可边会丧失性能?
2. 为什么可变变量会提升性能?

[FishGoddess]

不一定吧，不可变也可以是指针传递，可变也可以是值传递。。

[yxxuweb]

你这个回答这不是误解人么？

[youwillbe]

这个问题怎么说呢，怎么就叫安全性了？像c那样指针写越界我们可以说是不安全的，至于可变不可变，在不同的编程范式中有不同的需求，在函数式编程中可变性代表着副作用，唯恐避之不及，可在命令式编程或者面向对象编程中，就是靠副作用来编程的，没了可变性，代码都不能好好写了，所以彼之蜜糖，吾之砒霜，要辩证的看。灵活性当然也是这个道理。
至于性能，这个更没法这么绝对和笼统的说了，c性能好是因为直接指针读写内存吗？是因为长时间一代代的编译器优化好嘛，所以，如果性能不好，不在于你使用可变变量或不可变变量，而是编译器不行

[Xingtxx]

分析问题的核心点

1. 不可变带来的安全性
   这部分是正确的。不变性（immutability）在编程中确实可以提高安全性，因为它可以防止无意的变量修改，从而避免引入难以调试的 bug。例如，在多线程环境下，不可变变量天然是线程安全的，因为它们不能被修改，不需要担心数据竞争。

Rust 中默认变量是不可变的，这种设计初衷正是为了提高代码的安全性和可预测性。

2. 不可变变量的“性能问题”
   这部分是值得商榷的。原文提到“不可变变量丧失了灵活性和性能”，但实际上，不可变变量并不一定会导致性能问题，甚至在某些情况下还有助于性能优化。

不一定需要重新创建变量： Rust 中的不可变变量并不意味着你每次都需要重新分配内存。例如：

rustCopy code
let x = 5;
let y = x + 1;
在这种情况下，x 和 y 都是不可变的，但由于 Rust 的编译器优化，x 和 y 的值可能直接存储在寄存器中，根本不会涉及任何“内存对象的再分配”。

编译器优化： Rust 是一门静态编译语言，编译器会尽可能优化代码。在不可变变量的情况下，编译器通常可以推断出变量的生命周期和作用范围，从而更高效地管理内存。这在某些情况下甚至比可变变量更高效。

性能瓶颈更依赖于具体场景： 如果你的代码需要频繁修改一个变量的值（例如循环计数器），使用可变变量可能会更高效；但如果一个值是固定的，不可变可以减少额外的复杂性和潜在的开销。

3. 可变变量的“性能优势”
   原文提到“可变变量最大的好处就是使用上的灵活性和性能上的提升”，这也需要具体问题具体分析。

灵活性： 确实，使用可变变量在某些场景下更方便。例如，当一个值需要在多个操作中逐步修改时，使用可变变量会让代码更简洁。

性能： 可变变量并不总是性能更高。Rust 的编译器会对不可变和可变变量分别进行优化，性能差异更多取决于编程场景，而不是变量的可变性。例如，在多线程程序中，使用不可变变量可能避免了一些同步机制，从而提升性能。

改进后的表述
根据以上分析，可以将这句话改写为：

“不可变变量可以提高代码的安全性和可预测性，在某些情况下还可能通过编译器优化带来性能优势。但它可能会丧失一定的灵活性，例如当需要频繁修改值时，使用不可变变量可能显得不够直观或高效。而可变变量则提供了更大的灵活性，在需要频繁修改值的场景下可能更适合，但也需要更小心地管理以避免引入错误。”

总结
是否选择可变或不可变变量，取决于具体的使用场景和需求。在 Rust 中，编译器的优化机制使得不可变变量并不一定有性能劣势，而可变变量也并不是性能更高的万能选择。合理使用两者，结合 Rust 的所有权、借用和生命周期机制，才能编写出高效、安全的代码。

[Xingtxx]

核心点 就是看 rust 编译器优化方式

[meteorzh]

fn main() {
let e;

Struct { e, _ } = Struct { e: 5, f: 6 }; // 编译报错

Struct { e, .. } = Struct { e: 5, f: 6 }; // 编译报错

assert_eq!(5, e);

}

struct Struct {
e: i32,
f: usize
}

结构体解构赋值怎么忽略字段呢？

[meteorzh]

使用“..”忽略字段，运行没有问题，运行一次后就没有编译错误了，应该是工具的问题

[yAntPower]

我也有这个问题。没完全搞明白。。。。

[lonexw]

这地方本质上应该用到了模式匹配，可以学完那块回头再来看看

[wgl758]

fn main() {
struct Stu {
name: String,
}

let Stu { name, .. } = Stu {
    name: String::from("tom"),
};

println!("tom's name={}", name);

}

//没毛病

[changuoqiang]

变量和常量还有一个区别，变量在栈stack上动态分配，而常量分配在.data静态数据段上，常量会一次性静态加载，使用时直接寻址，性能会更好。

[zenoWZH]

所以是不是可以这么理解，let比起const的好处在于可以交给编译器优化内存分配，坏处就是慢了点

[xieguozhong]

我记得常量会在编译时直接做替换处理吧, 比如const PI = 3.1415, 那么编译时后面用到PI的地方都会被直接替换为3.1415

[dkl78167816]

我的理解，这里let和let mut的关系，就相当于其他语言的var和const关系，是常见的特性，不知道对吗

[dkl78167816]

留言急了，没看到后面的部分

[godsoul]

使用下划线开头忽略未使用的变量， 这里不使用下划线，也不会警告了。

[lesonky]

作为一个 ts 程序员，平时写代码，变量大部分都是 const 来定义，只有在真的需要重新赋值的地方才用 let，我觉得这和 let 与 let mut 差不多的思路。
可变与不可变，是两个状态，为啥需要3种定义方式？
let 和 const 的在rust里面的区别到底在什么地方呢，仅仅是语义上的区别吗？

[duwoodly]

我的理解是从内存分配上，let声明的变量，编译器可以优化，例如是字面量值的时候，编译器可以把它放到程序只读区，如果是let 赋的值是运行时的，就是在栈上。 而const声明的变量的值是只能在程序只读区。

[fadedzipper]

我觉得可以参考一下c++，c++ 有const，没有const，和constexpr。constexpr表示编译期常量。我不很确定的认为rust 的const跟c++的constexpr比较像。const也可以分配在栈上的。内存位置并不是区别。

[mysdr]

我的理解是const既不可变也不可修改，let可变不可修改（比如一个赋值后不会被修改的随机数），let mut可变可修改

[Buer-Nahida]

let定义的变量只能赋值一次，且存储在栈上

fn main() {
    let a = 10; ///< 正确
    let b: i32;
    b = 20; ///< 正确
    b = 10; ///< 错误
}

let mut就好懂了，不举例了
const是常量，存储在.data静态数据段上，必须手动确定类型且在编译时确定数据

fn main() {
        const a = 10; ///< 错误
        const b: i32;
        b = 20; ///< 错误
        b = 10; ///< 错误
        const c: i32 = 10; ///< 正确
}

[w4c4dwsz]

const是常量，存储在.data静态数据段上，必须手动确定类型且在编译时确定数据

const的值必须在编译前确定
而let的值可以在程序运行时指定

如

fn add(a : i32, b : i32) -> i32{
  let aa = a;
}

该式子中a就是由函数传递的参数决定的，在程序运行期间确定，确定后无法修改

[yammyxing]

课后练习精心设计，很棒～

[cxw620]

对新手极其friendly... 感谢上天让我搜到了这个Course

[zjgpost]

为什么我照例子写的，执行cargo run,非但没报错，还正确打印出来了，
let x = 5;
println!("The value of x is: {}", x);
let x = 6;
println!("The value of x is: {}", x);
打印中，5和6，怎么回事？

[zjgpost]

难道最新版本改了？

[zombie110year]

1. 你预期的结果是什么？
2. 你的 let x = 5， let x = 6 其实是绑定了两个变量，只是第二个变量把前一个同名变量遮蔽了而已。
3. 后面那个报错（其实只是警告）的意思是“变量不需要是可变的”，只要你声明了mut却不修改变量的值就会有这个警告。

[zjgpost]

非感谢您的回复，只是没太明白！绑定两个变量，不是只能同一时间只能绑定到一个变量吗？那mut这个用处在哪里呢？

[zjgpost]

看了后面的文档，明白了，感谢回复！

[zjgpost]

有点粗心，发现我第二句多写了let,相当于重新声明了

[cmlark]

struct Struct {
    e: i32
}

fn main() {
    let (a, b, c, d, e);

    (a, b) = (1, 2);
    // _ 代表匹配一个值，但是我们不关心具体的值是什么，因此没有使用一个变量名而是使用了 _
    [c, .., d, _] = [1, 2, 3, 4, 5];
    Struct { e, .. } = Struct { e: 5 };

    assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
}

我不理解这个解构式赋值，请问何为“解构”呢，在赋值语句哪里中括号“[]”和小括号“（）”有什么区别吗，“...”又是做什么用的呢 , 下划线"_"说是匹配一个值，在上面的例子代码中匹配的是 e 吗？

[cmlark]

看了下面其他朋友的提问好像能理解一点了

[OxfordStreet]

我知_ 和 ..的匹配了；() 和 [] 有什么区别？

[olivewind]

写得太棒了！

[chenyulun]

"但是 let 会重新绑定，而这里仅仅是对之前绑定的变量进行再赋值。"这句话应该是
“但是 let 会重新绑定，而这里仅仅是对之前未绑定的变量进行绑定。”
前面说过不能叫赋值，应该叫绑定

[ComeStart]

变量和值互相绑定，就像狐狸和小王子互相拥有一样

[xll970211]

rustc 1.82.0 (f6e511eec 2024-10-15)
这版本下修改变量不需要加mut，加了还会提示去掉

[xll970211]

但是在变量结构中因为下面修改了b，如果不加mut的话，会报错。

[xll970211]

是我编写错误，在第二次给变量绑定值的时候，加了let，变成重新绑定了，所以存在问题。

[Paul-from-NJTech]

我有一些疑问，遮蔽变量之后，之前的变量我们无法访问，就意味着之前的变量我们不再需要，那么还存放在栈中是不是会增加内存的开销呢？

[zhoukekestar]

「课后练习」好评

[Raven95676]

常量似乎也能遮蔽

fn main() {
    const A:i32=123;
    println!("{}",A);
    {
        const A:&str="hello";
        println!("{}",A);
    }
}

输出：

123
hello

[Raven95676]

研究了一下，是作用域（

[chasays]

[c,..,d, _] = [1,2,3,4,5];这个很巧妙， ..代表中间的无数个， _相当于一个占位符，d 就是倒数第二个；
c 是第一个，所以他们的值就是 c =1 ， d =4

[chasays]

{} 这个屏蔽的用法 不错， 还you 就是 覆盖只能是同一个数据类型的；

[yxzzlwj]

坏了，我不是目标读者

[sheyifan]

mut可以用于变量赋值表达式左侧。用于右侧的时候只能是&mut（可变引用）的场景

[ravenxrz]

不太能理解为什么设计遮蔽这样的东西，虽然命名简单了，但是看代码的时候会觉得乱，得就近匹配变量在当前的context下是什么含义。

[youwillbe]

感觉奇怪就不用这个特性就好了呀

[ravenxrz]

将本身无需改变的变量声明为不可变在运行期会避免一些多余的 runtime 检查。
这里是“声明为可变”？

[youwillbe]

你为啥觉得声明为可变能避免运行时检查？

[ravenxrz]

这答非所问 发自我的iPhone

…

------------------ Original ------------------ From: 布里焦焦迪布利多 ***@***.***> Date: Wed,Dec 31,2025 10:09 AM To: sunface/rust-course ***@***.***> Cc: Raven ***@***.***>, Comment ***@***.***> Subject: Re: [sunface/rust-course] basic/variable (Discussion #613) 感觉奇怪就不用这个特性就好了呀 — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***>

[ravenxrz]

这里看错了。理解成了不变量有检查。   发自我的iPhone

…

------------------ Original ------------------ From: 布里焦焦迪布利多 ***@***.***> Date: Wed,Dec 31,2025 10:10 AM To: sunface/rust-course ***@***.***> Cc: Raven ***@***.***>, Comment ***@***.***> Subject: Re: [sunface/rust-course] basic/variable (Discussion #613) 你为啥觉得声明为可变能避免运行时检查？ — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***>

[chenjing1294]

有个问题请教，我的理解是let a = 12，那么不能再给a赋值，为什么下面这段也是错的？

struct A {
    s: Vec<u8>,
}

fn main() {
    let a = A { s: Vec::new() };
    a.s.push(3u8);//错误
}

[lighterEB]

mut绑定的是属性不是类型的属性，和类型无关。