Rust学习笔记003:语句和表达式+函数+控制语句:IF,MATCH,LOOP

发布时间:2023年12月31日

语句(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);
}
文章来源:https://blog.csdn.net/ResumeProject/article/details/135317548
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。