basic/flow-control

[giscus[bot]]

basic/flow-control

https://course.rs/basic/flow-control.html

[Tailless-Monkey]

这里是因为所有权吗？是的话可能要强调一下

好像没有强调么，到底是不是呢？

[Sword-Of-Code]

上面代码分开了，没有编辑好。
也就是说，a 在for 循环迭代的时候，没有使用 &mut a; 那按作者所说应该是 copy 了数据，没有借用所有权。
为啥他能改变数组元素，而且打印之后原数组也改变了呢？

[qzlearn]

循环中a[0] = 1；是直接对原数组进行操作。copy指的是for item 中item里的值是copy过的。

[Sword-Of-Code]

哦哦，感谢讲解

[Sword-Of-Code]

这里要说一句，作者在前几章讲的比较好。但到泛型之后讲的跳跃性就很强了，没有官方的书讲的好，而且会引入各种语法糖（还不提前介绍）

[hiqishen]

因为数组里面都是基本类型数字,默认是copy 没有转移所有权, 如果是String就不行了

[mxismean]

for循环：（这里是因为所有权吗？是的话可能要强调一下）

这个信息是MR的评论吧？😂

[Nanbert]

if 语句块是表达式，如果不用到if中的值，那每次用if就都应该在大括号后加分号，为啥在程序中间我不加也行

[KunPengRen]

应该例子里面是表达式吧

[chenxiaochun]

有道理，可能是当时翻译者的一句内心独白

[ghost]

break的嵌套和标签的功能也列一下比较好吧:)

[lumina37]

现在好像还没加上，但练习里有https://zh.practice.rs/flow-control.html

[dice246]

为啥到这里就没评论了，我还想看看评论

[dice246]

好吧，是没翻到下面

[meimeitou]

鲁迅： 我没说过！

[panxy2013]

怀念鲁迅先生, 我语文不好, 记得 <孔乙己>, <从百草园到三味书屋>. 啥时候可以真正 Open 起来呢...

[rien7]

为什么 for 循环中会发生所有权的移动而 while 循环不会呢？是因为 for ... in ... 的缘故吗？

[anson0370]

是因为 for i in collection 本质上是 for i in collection.into_iter() 的 sugar 。而如果你看一下 .into_iter() 的签名的话会发现是这样的 fn into_iter(self) -> Self::IntoIter 注意这里的入参是 self 而不是 &self ，就是在这里发生了 move 。

[malyjacob]

没有switch语法吗？

[loheagn]

其他语言的switch对应的是rust中的match ~

[Yiyuiii]

1..=5是什么原理..?

[zrll12]

应该就是1..5加上一个5？

[BiteFoo]

应该就是[1,5)这样的区间表达式，如果是1..5 等价于[1,5]这样的吧

[BiteFoo]

写错了，是1..=5是[1,5]1..5 是[1,5)这样的=_=||

[panxy2013]

感觉 Rust 一个门槛是各种特殊的语法形式, 只能靠熟能生巧,见多识广么. 5555

1..=5 // 1,2,3,4,5 序列
1..5 // 1,2,3,4 序列

[mudssky]

1..5,就类似于python里的range(1,5)
powershell里面也有1..5的语法,不过那是数组的语法糖,而且是前闭后闭的

[PengIoT]

如果不使用引用的话，所有权会被转移（move）到 for 语句块中，后面就无法再使用这个集合了)：

这句话没有理解， 下面的代码运行没问题。

  let my_array  = [1, 2, 3];

  for n in my_array {
    print!("{}\t", n);
    print!("{:?}", my_array);
  }

  for n in my_array {
    print!("{}\t", n);
    print!("{:?}", my_array);
  }

[fung-hwang]

i32实现了copy特征，自然没有move的说法。换String数组试一下。
有必要复习一下所有权的那一章。

[PengIoT]

谢谢指教，的确是这样。但如果按下面这样定义 String 数组，也不需要引用， 因为 str_array 的类型 [&str; 3] 本身就是引用 。

  let str_array = ["hello", "world", "rust"];

  for n in str_array {
    print!("{}\t", n);
    print!("{:?}", str_array);
  }

  for n in str_array {
    print!("{}\t", n);
    print!("{:?}", str_array);
  }

当然也可以用 引用 的方式，但 n 的类型就成了 &&str, 因为恰巧是 String 切片, 所以 n 和 *n 都可以得到值。

let str_array = ["hello", "world", "rust"];

  for n in &str_array {
    print!("{}\t", *n);  // 解引用 *n
    print!("{:?}", &str_array);
  }

  for n in &str_array {
    print!("{}\t", n);  // only n
    print!("{:?}", &str_array);
  }

[fung-hwang]

是的，但你应该定义一个String数组，而非&str数组。
在实现copy特征的方面来说，&str和i32是一样的（都实现了）

let strings = [String::from("abc"), String::from("cba"),];
// move
 for str in strings {
        println!("{}", str);
}
// borrow
 for str in &strings {
        println!("{}", str);
}

[ljq]

这个针对具有copy特征的简单内置类型是没问题的，其他语言也有类似的针对简单类型的处理方式就是直接copy，因为简单类型本身直接copy的开销就小，不要类似复杂集合类型的处理方式。例如Golang针对简单类型变量直接分配内存无须使用指针。

[Icemans007]

使用一楼的例子，自己对 array 数组理解比较欠缺：

fn main() {
    let str_array = [3, 4, 45];
    for n: i32 in str_array {
        println!("ptr:{:p}\t val:{}", &n, n);
    }
    println!("{:?}", str_array);    // 可以正常使用 str_array
    println!();

    let str_array = ["hello", "world", "rust"];
    for n: [&str; 3] in str_array {
        println!("ptr:{:p}\t val:{}", n, n);
    }
    println!("{:?}", str_array); // 可以正常使用 str_array
    println!();

    let str_array = [String::from("hello"), String::from("world"), String::from("rust")];
    for n: [String; 3] in str_array {
        println!("ptr:{:p}\t val:{}", &n, n);
    }
    // println!("{:?}", str_array); // !!!!!!不能正常使用 str_array 因为被 move 会 drop
}

第一种比较好理解，[i32; 3] 本身有 copy 特征，所以在for环境中是复制，不存在使用权转移；
第二种我开始理解是【我的理解有错的】，[&str; 3] 它肯定不是copy类型，str_array将move到for in，但是发现结尾可以使用 println!("{:?}", str_array);，所以我想，前面例子说for in 是语法糖，默认是调用into_iter()，是不是nto_iter()返还了使用权？
可等到第三种，我开始以为会和第二种一样，返还了使用权，但发现报错！
请问大佬能分析错array在内存中到底是什么结构？

[123chen-jiahui]

想问问break后面加和不加分号的区别

[ZLD1819858]

参见章节：<语句和表达式>中有说到：对于 Rust 语言而言，这种基于语句（statement）和表达式（expression）的方式是非常重要的，你需要能明确的区分这两个概念, 但是对于很多其它语言而言，这两个往往无需区分。基于表达式是函数式语言的重要特征，表达式总要返回值。

同时你可以在vscode中编码试试，在break后面加了分号之后即是语句，而不是表达式，不加分号是表达式，在例子中是为了将loop表达式的结果返回，那么break后面不应该加分号。
（√）let result = 表达式;
（X）let result = 语句;

[bluecode2017]

和return一样，加不加; 好像都是一样的。不报错。

[bluecode2017]

“在例子中是为了将loop表达式的结果返回，那么break后面不应该加分号。”
这个加；也可以的。 例子里加了，不报错。https://rust-lang.github.io/rfcs/1624-loop-break-value.html

[Bourne115]

目的：语句的目的是执行操作，而表达式的目的是计算并返回值。
结果：语句不返回值（或者返回一个隐含的单位值，如在C和Rust中的void），而表达式返回一个值。
结束符号：在某些语言中，语句以分号结束，而表达式不需要分号。

[ZLD1819858]

Done.

[jay-col]

作为一名几年python开发者学到这里，熟悉感拉满，处处似曾相识，预言以后rust一定会成为现在广泛开发者的第二语言甚至是第一语言。

[ljq]

As a programming language, Rust is excellent at handling data competition, similar to the unix minimalist philosophy.

[SherlockGy]

这里没有介绍到 label

[fadedzipper]

这里是因为所有权吗？是的话可能要强调一下
我觉得应该是的。
就像在the book里面，有一个例子是字符串返回第一个word，需要返回String的切片(引用)，而不是第一个单词的起始位置索引和结束位置索引。索引是一个整数。String如何变化并不会对那个索引产生什么影响。但是String的切片本身是引用，就需要符合引用借用的规则，只有安全的情况下才可以通过编译。

[Wh1isper]

我怀疑这两种循环在数组长度可知的情况下，编译后的效率将是一样的，不建议按照Python这类逐行解释的语言的思路来看这里的性能问题

当然，使用第二种遍历数组肯定是更安全的

// 第一种
let collection = [1, 2, 3, 4, 5];
for i in 0..collection.len() {
  let item = collection[i];
  // ...
}

// 第二种
for item in collection {

}

[Icemans007]

不一致哦，每次执行 collection[i] 时，内部都会执行一次是否超出边界的检查

[wangyaoyao233]

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("the value is: {}", element);
    }
}

for循环里面的, 正常不应该是 *element 吗，element不应该是指针吗。

[anson0370]

你说的没错 element 是 &i32 类型的，但是 println! 宏可以自动解引用。

[wangyaoyao233]

嗯。谢谢。来个直击灵魂的问题，指针和引用有什么区别？

[anson0370]

好问题，个人理解这东西从汇编层面是没什么区别的，它们都是一个指向内存地址的值，更多是语义上的区分。引用听起来就是和一个真实存在的东西有关系，而指针更独立。比如C++中指针可以为空，可以瞎指，但引用一定和某个存在的对象绑定。
正因为本质上没啥区别所以很多时候我们会混用，比如C++中*操作符我们也是叫做解引用……

[wangyaoyao233]

确实。我问了一下chatgpt, 它说在rust中，引用是对指针的一种封装，底层包含指向的指针和一个管理生命周期的变量。

[duanyuluo]

指针通常说的是C中的pointer，他就是裸的指向内存地址的int类型。引用则是一个封装，前面也讲过了，他实则是一个结构体，包含了
{
pointer: usize,
mem_size: usize,
cap: usize
}
这里说明一下，C中pointer也是有mem size的，只不过是隐含在编译时，通过pointer type来确定的，比如int*，就说明pointer指向一个4 bytes 的内存。

[freesrz93]

不知道为什么作者很喜欢对比 JavaScript，按理说 rust 这种系统级语言应该跟 c++ 对比吧，当然纯粹语法层面都可以比较啦。。
另外用 for...in... 迭代集合元素和 python 是类似的，但是对应到 JavaScript 应该是 for...of... ，而不是 for...in...，后者在 JavaScript 里会迭代 object 的所有可迭代 properties

const arr = [3, 5, 7];
arr.foo = "hello";

for (const i in arr) {
  console.log(i);
}
// "0" "1" "2" "foo"

for (const i of arr) {
  console.log(i);
}
// Logs: 3 5 7

[davelet]

is there any programing language not supporting 'if' and 'else'?

ChatGPT:
Yes, there are programming languages that do not support constructs like if and else for conditional branching. Some examples of such languages include:

Assembly Languages: Low-level assembly languages often lack high-level control structures like if and else. Instead, they rely on jump and branch instructions for conditional execution.
Brainfuck: Brainfuck is an esoteric programming language with a minimalistic set of commands. It doesn't have built-in if or else constructs.
Whitespace: Whitespace is another esoteric language where the code consists only of whitespace characters (spaces, tabs, and line breaks). It doesn't have explicit if or else statements.
INTERCAL: INTERCAL is intentionally designed to be difficult to program in, and it avoids conventional constructs like if and else.
Malbolge: Malbolge is known for its extreme difficulty in programming. It is intentionally designed to be incredibly challenging to write code in and lacks common control structures.
Befunge: Befunge is a two-dimensional programming language that doesn't have conventional control structures like if and else.

[jinmingzhuo]

笔记：只有loop可以用break返回value，while和for只能返回()

[Innovationlzc]

有个疑问，fn main() {
let mut counter = 0;

let result = loop {
    counter += 1;

    if counter == 10 {
        break counter * 2;
    }
};

println!("The result is {}", result);

}
这里的break是否需要带”；“，我测试代码发现有分号和没有不影响结果输出。既然loop是表达式，返回的值是counter * 2还是counter * 2;，编译器能自动识别匹配吗？

[CynicalHeart]

提问：
loop既然是表达式，那么内部返回的那一行，也就是break counter * 2;，应该是表达式啊，为什么会有分号？

[2048920439]

这应该和ruturn类似,显式使用了返回语法带上分号也是在申明该loop语句的返回值

[ice1835]

这方面 还是go简单。
一个for就可以顶rust的 for while loop

[hanguangyi]

+= 也是循环结束后才生效

[hanguangyi]

测试了下立即生效

[leo-davisf]

这里是不是缺了个break和continue标签的用法，看练习里有

[Endermanbugzjfc]

希望可以讲讲循环标签的用途
https://doc.rust-lang.org/rust-by-example/flow_control/loop/nested.html#nesting-and-labels

[Endermanbugzjfc]

这功能貌似不太受青睐

[Wan-Yifei]

while 和 loop 都不要求所有权吗？从课后练习看视乎是这样的。

[Icemans007]

这里比较喜欢golang语言的大道至简，while, loop 都可以使用都集中在 for 中
while boolen {} ==> for boolen {}
loop {} ==> for {}

[cpython666]

while: 兄弟你再坚持一下，我快出来了🤫🤫

[simexce]

while true {} 这货怎么了？