basic/variable

[sunface]

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

[darkestsirius]

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

[changsen-dev]

@C1tizenZ 假如两个名字相同的变量合法存在，那么我在接下来的代码中调用a，程序怎么知道我要用哪个？

[BloodLucia]

就近原则

[jeffacode]

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

[underwoodnoble]

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

[MrStrangeBao]

可以这样理解:
let a = 123; // 定义常量
a = 1234; // 不可以修改,报错
let a = 321;// 覆盖 之前定义的
let mut x = 1; // 定义变量
x = 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. 为什么可变变量会提升性能?

[zhengtong0898]

我自己来尝试回答一下:

1. 为什么不可变会丧失性能?
   分两种情况，第一种是基础类型，第二种是特定数据结构。
   基础类型: 就是达成共识的常量数据，不会去修改，编译器会优化它，性能会得到提高。
   特定数据结构: 在特定条件下需要修改不可变变量，那么就只能采取复制、覆盖的形式来完成修改，这个过程涉及到CPU搬运和内存的拷贝开销，因此会丧失性能。

2. 为什么可变变量会提升性能?
   因为通过指针直接修改值比复制、覆盖更少的CPU执行和零内存开销，所以相比较之下性能会更好。

[FishGoddess]

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

[yxxuweb]

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

[youwillbe]

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

[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,相当于重新声明了

[ivy-lun]

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 吗？

[ivy-lun]

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

[OxfordStreet]

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

[olivewind]

写得太棒了！

[zcjie1]

看了一下对应的汇编代码，总结如下：

1. 使用const定义的变量，存储在.rodata区
2. 使用let且不使用mut定义的变量，存储在栈中；同时，当定义同名变量时，会在栈中另外开辟一块内存存储
3. 使用let且使用mut定义的变量，存储在栈中；同时，当对该变量进行更改时，会在同一内存处做更改

[KirsminX]

对应的习题可能超前了。这一节没有 String 类型，只有 &str
https://practice-zh.course.rs/variables.html

// 修复错误
fn main() {
    println!("{}, world", x); 
}

fn define_x() {
    let x = "hello";
}

[kgagag]

我用rust开发了一个java虚拟机demo
https://www.bilibili.com/video/BV1fE421L7Hp/?spm_id_from=333.999.0.0

[sohide]

变量遮蔽特性会带来代码阅读和维护上的困难，加大心智负担，写代码的人是爽了

[youwillbe]

想太多

[Andy001847]

变量遮蔽怎么说呢？好用与否感觉和编辑器有很大的关系，虽然在一定程度上可以减少相同意义变量名称的定义，但是如果使用变量遮蔽较多时，自己查看代码时有时候会搞混。有利有弊吧。

[huan-zz3]

明显感受到上强度

[jieqiyue]

我来说一个点，貌似没看到人提到

fn main() {
    let x = 5;
    // 在main函数的作用域内对之前的x进行遮蔽
    let x = x + 1;

    {
        // 在当前的花括号作用域内，对之前的x进行遮蔽
        let x = x * 2;
        println!("The value of x in the inner scope is: {}", x);
    }

    println!("The value of x is: {}", x);
}

这里面的第二个x，是重新分配了内存了吗？因为文中说let是重新分配内存了。

[Paul-from-NJTech]

是的，重新分配内存了。

[kerongw]

果然难学，光一个变量整出这么多花样来
let a = 10;
a = 20;
let b = 10;
let b = 20;
let mut c = 10;
c = 20;

[socay1]

你这个写法有问题。 rust 中变量默认是不可变的。 因此 let a = 10; 之后 a = 20 是违背语法的 kerongw ***@***.***> 于2024年9月12日周四 17:25写道：

…

果然难学，光一个变量整出这么多花样来 let a = 10; a = 20; let b = 10; let b = 20; let mut c = 10; c = 20; — Reply to this email directly, view it on GitHub <#613 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AFQKY2LSP24SV2DR5EQ3QADZWFMZLAVCNFSM5RW37LJ2U5DIOJSWCZC7NNSXTOSENFZWG5LTONUW63SDN5WW2ZLOOQ5TCMBWGI2DANJW> . You are receiving this because you commented.Message ID: ***@***.***>

[xbsheng]

常量既然值不能变了，类型可以推导出来吧，为什么还必须定义类型呢？rust这样设计有什么目的吗

[LancelotSaki]

rust咋不都像js一样用var、let、const替代呢。

[chenyulun]

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

[ComeStart]

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

[xll970211]

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

[xll970211]

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

[xll970211]

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

[Paul-from-NJTech]

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