basic/variable

[sunface]

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

[darkestsirius]

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

[changsen-dev]

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

[denniskoay]

就近原则

[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]

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

[youwillbe]

你这小括号还能匹配中括号呢？

[lonexw]

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

[lesonky]

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

[wgl758]

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

元组只能解构元组

[edisonLzy]

解构赋值和 ts 很像

[keigu2008]

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

[maolonglong]

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

[stevenkitter]

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

[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时，没有报错啊

[HydroCarbon]

试了一下，编译不通过的，不知道你是什么情况
--> src/main.rs:8:14
|
3 | let mut string = "Hello, world";
| -------------- expected due to this value
...
8 | string = string.len();
| ^^^^^^^^^^^^ expected &str, found usize

$ rustc -V
rustc 1.60.0 (7737e0b5c 2022-04-04)

[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 = '你好哦'; // ~~改成这样，则编译通过的

大概是这么回事

[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可变可修改

[SR-MyStar]

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]

写得太棒了！

[littlestacknie]

第一天打卡！看我可以坚持几天！

[hdsword]

@isunface 能不能跟你邮件联系呀，有些问题

[q13945951476]

Struct {e} = Struct {e:5};
这个e后面为什么要加 ..
正常不应该这么写么？结构体里只定义了一个e，为啥加 .. 没理解上去

[youwillbe]

是不用，Struct 已经确定了只有一个字段，不加更明确，加了也不会报错

[raotaohub]

fn main() {
    let (a, b, c, d, e); 
    (a, b) = (1, 2); // 对这里有些不理解，上面是不可变声明，为什么可以再赋值。
    // ... 下面同理
}

能否理解成（我就说 let 声明不掺入 mut ）

1. 变量绑定（声明时绑定，不可再绑定）

let a = 1;
a = 2 // error

2. 变量声明 + 赋值 （声明时不绑定，可以通过后续赋值(此时不知道要叫赋值还是绑定)）

let (b);
b = 2 // success

[yjshi2015]

Rust学习第3天，心情很平静……

[youwillbe]

想表达什么？

[Skyfacon]

打卡

[hintcnuie]

Rust 光是在变量这一块，设计的就比较复杂啊，变量绑定，变量解构，变量遮蔽， 可变变量， 不可变常量。。。。。。东西太多了

[xieguozhong]

变量遮蔽(shadowing) 处建议画个两种方式执行后内存数据示意图

[J1nH4ng]

个人理解应该是这样的：

声明变量时指向 tag a'，当进行变量遮蔽是，指向了 tag a''，对于外部观察来看，表现为一个变量 a，对于内部来看，指向不同，类型可能也不同。

[lxygithub]

可变的直接用var多好，还要多写一个mut😅

[jaweDream]

mut会有类型限制

[0x51E1]

不加mut都是不可变，那么为什么要多一个常量关键字？

[J1nH4ng]

常量和变量在内存分配上的策略是不一样的。对于嵌入式的部分硬件来说，出于性能的考量，并不需要变量。

[0x51E1]

防止多想名字，那应该设置mut，而不是不可变一直赋值

[J1nH4ng]

个人理解来说，对于维护一个项目来说，新建一个新的变量名比对于旧的变量重新赋值更简单而且安全一点。因为你不知道旧的变量或者常量是否在某个关键的地方发挥了什么作用。

[J1nH4ng]

rust 可以变量遮蔽，可以重复用一个命名的。

[Zhengchen2029]

data races 数据冲突也不错，抽象底层读写数据的时候，避免又读又写，机组。

[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