语句（Statements）和表达式（Expressions）
1. 语句（Statements）：
语句是执行一些操作但不返回值的代码单元。例如，声明变量、赋值、函数调用、宏调用等都是语句。
// 声明变量的语句
let x = 5;
// 表达式语句（函数调用）
println!("Hello, World!");
// if 语句
if x > 0 {
println!("x is positive");
} else {
println!("x is non-positive");
}
// 函数定义语句
fn my_function() {
// 函数体
}
在 Rust 中，语句末尾不需要分号，但如果在语句之间有多个表达式，需要用分号分隔。
2. 表达式（Expressions）：
表达式是计算并产生一个值的代码单元。表达式可以是一个常量、变量、运算、函数调用等。每个表达式都有一个类型，并产生一个值。
let y = {
let x = 5;
x + 1 // 这是一个表达式
};
println!("The value of y is: {}", y);
在上述例子中，y 的值是一个块（Block）的最后一个表达式的值，即 x + 1。
Rust 中的函数调用、宏调用、赋值等通常是表达式。例如，let x = 5; 本身就是一个表达式，它产生 ()（unit 类型的值）。
let x = {
let y = 5;
y * 2 // 这是一个表达式
};
在这个例子中，块 { ... } 作为一个表达式被赋值给变量 x。
- 下面的例子输出5
函数
函数与命名 fn name() {}
- 一些编程语言和框架强烈推荐或者约定使用 snake case 风格。例如，Rust、Python、Ruby 等都鼓励使用 snake case。Snake case 是一种命名规范风格，通常用于变量名、函数名和文件名等标识符。Snake case 的特点是将单词用下划线连接，并全部小写。这种风格使得标识符更易读，也更符合一些编程语言和工具的命名约定。
Snake case 示例：
- 变量名：
my_variable - 函数名：
calculate_sum - 文件名：
main_module.rs
在Rust中，snake case 是一种常见的命名风格，符合 Rust 的命名规范。以下是一些 Rust 中使用 snake case 的示例：
fn calculate_sum(a: i32, b: i32) -> i32 {
// 函数体
a + b
}
const MAX_NUM: usize = 100;
struct MyStruct {
field_one: i32,
field_two: f64,
}
fn main() {
let my_variable = 42;
let another_variable = 3.14;
}
函数参数
-
基本类型约束： 需要在函数参数中使用特定的类型来约束参数的类型。例如：
fn print_number(num: i32) { println!("Number: {}", num); }在上述例子中，
num参数的类型被限定为i32。 -
使用泛型时： 使用泛型可以更灵活地约束参数的类型。例如：
fn print_generic<T>(value: T) { println!("Value: {:?}", value); }在这里，
T是一个泛型参数，可以用于表示不同类型的参数。
函数返回值
- 在 Rust 中，函数的返回值可以通过
->符号指定。Rust 的函数可以返回各种类型，包括基本类型、复合类型、引用和自定义类型等。
返回基本类型：
fn add(a: i32, b: i32) -> i32 {
a + b
}
fn main() {
let result = add(2, 3);
println!("Result: {}", result); // 输出：Result: 5
}
在上述例子中，add 函数返回一个 i32 类型的整数。
返回复合类型：
struct Point {
x: f64,
y: f64,
}
fn create_point(x: f64, y: f64) -> Point {
Point { x, y }
}
fn main() {
let point = create_point(1.0, 2.0);
println!("Point: ({}, {})", point.x, point.y); // 输出：Point: (1, 2)
}
在这里，create_point 函数返回一个自定义的 Point 结构体。
返回引用：
fn get_first_char(s: &str) -> Option<char> {
s.chars().next()
}
fn main() {
let result = get_first_char("hello");
match result {
Some(c) => println!("First character: {}", c),
None => println!("String is empty"),
}
}
在这个例子中，get_first_char 函数返回一个 Option<char> 类型，表示可能返回一个字符或者 None。
返回多个值：
Rust 中没有直接支持返回多个值的语法，但可以使用元组、结构体或者 Result 类型来返回多个值的组合。
fn calculate_values(a: i32, b: i32) -> (i32, i32) {
(a + b, a * b)
}
fn main() {
let (sum, product) = calculate_values(3, 4);
println!("Sum: {}, Product: {}", sum, product);
}
在这里，calculate_values 函数返回一个包含两个值的元组。
if表达式：
- 需要注意的一点：if后必须是一个布尔类型，像c++就会类型转换
let number = 5;
if number > 0 {
println!("Number is positive");
} else if number == 0 {
println!("Number is zero");
} else {
println!("Number is negative");
}
// if 表达式的值可以被赋给一个变量
let result = if number > 0 { "positive" } else { "negative" };
println!("Result: {}", result);
if let
if let 结构用于简化 match 表达式中的单一模式匹配。
let favorite_color: Option<&str> = Some("blue");
if let Some(color) = favorite_color {
println!("Favorite color: {}", color);
} else {
println!("No favorite color");
}
match 表达式
match表达式用于模式匹配，可以更灵活地处理多种情况。
let fruit = "apple";
match fruit {
"apple" => println!("It's an apple"),
"orange" => println!("It's an orange"),
_ => println!("Unknown fruit"),
}
loop 循环
loop关键字用于创建一个无限循环，可通过break语句跳出。
let mut counter = 0;
loop {
println!("Counter: {}", counter);
counter += 1;
if counter == 5 {
break;
}
}
while 循环
while循环根据条件重复执行代码块。
let mut i = 0;
while i < 5 {
println!("i: {}", i);
i += 1;
}
while let
- 类似于
while循环，但是用于简化match表达式的单一模式匹配。
let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
while let Some(top) = stack.pop() {
println!("Popped: {}", top);
}
for循环
for循环用于迭代集合或者范围。
for number in 1..=5 {
println!("Number: {}", number);
}
let fruits = ["apple", "orange", "banana"];
for fruit in fruits.iter() {
println!("Fruit: {}", fruit);
}
