【Rust】002-基础语法：函数

蔚落 2023-10-15 15:05 21阅读 0赞

# 【Rust】002-基础语法：函数 #

### 文章目录 ###

*  【Rust】002-基础语法：函数
 *  一、概述
 *  二、函数
 *   *  1、基本函数
     *  2、参数
     *  3、即时补充：函数参数是 \`String\` 和 \`&str\` 的区别
     *   *  String
         *  &str
         *  对比
     *  4、返回值
     *   *  语句和表达式
         *  语句块示例
         *  返回值

# 一、概述 #

在 Rust 中，函数是组织代码的一个基本模块。前面几节中我们已经见过了 Rust 最重要的函数 main 函数，它是整个程序的入口。有了函数，我们就可以把代码逻辑片段封装在其中，从而提高代码的可读性和复用性。

# 二、函数 #

## 1、基本函数 ##

fn greet() {
        
        println!("Welcome!");
    }

## 2、参数 ##

// 主函数，程序的入口点
    fn main() {
        
        // 使用 let 关键字声明一个不可变变量 name，并初始化为 "訾博"
        let name = "訾博";
    
        // 将不可变变量 name 的引用传递给 print_name 函数
        // 注意：这里没有使用 to_string()，因为 print_name 接受的是字符串切片 &str 类型
        print_name(name);
    }
    
    // 自定义函数 print_name，接受一个字符串切片 &str 类型的参数 name
    fn print_name(name: &str) {
        
        // 打印输出 "name: " 和变量 name 的内容
        // {} 是一个占位符，用于插入变量的值
        println!("name: {}", name);
    }

## 3、即时补充：函数参数是 `String` 和 `&str` 的区别 ##

### String ###

*  `String` 是一个可变、可增长的字符串类型，存储在堆上。
 *  通常用于需要修改或动态构建字符串的场景。
 *  拥有该字符串的所有权。
 *  常常通过 `.to_string()` 或 `String::from()` 从一个字符串字面量创建。

let mut s = String::from("hello");
    s.push_str(", world!"); // 可以修改字符串

### &str ###

*  `&str` 是一个字符串切片，通常用作函数参数，表示对某个字符串的不可变引用。
 *  它是轻量级的，并且是借用的，所以不拥有该字符串的所有权。
 *  通常用于读取字符串，并且通常用于固定或已知长度的字符串。

fn print_name(name: &str) {
        
        println!("name: {}", name);
    }
    
    let s = String::from("hello");
    print_name(&s); // 可以传入String的引用
    print_name("world"); // 可以直接传入字面量

### 对比 ###

*  `&str`通常更快，因为它是不可变和轻量级的。
 *  `String` 在需要所有权或需要修改字符串时是必要的。
 *  在函数参数中，使用 `&str` 通常更灵活，因为它允许你接受任何字符串数据的引用。

## 4、返回值 ##

Rust 的函数可以返回一个值给它的调用方。不过在介绍返回值之前，需要插入两个概念的介绍——语句（statement）和表达式（expression）

### 语句和表达式 ###

语句通常表示执行一个动作，并且不会返回任何值。用 let 做变量绑定就是一个语句，例如：

fn main() {
        
        let x = 1;
    }

函数的定义也是一个语句。例如上面的 main 函数定义，整体就是一个语句。

刚才说了语句没有返回值，因此下面的写法是错误的：

fn main() {
        let x = (let y = 2);
    }

`let y = 2`是一个语句，没有返回值，因此不能把x绑定上去。

跟语句不同，表达式会求值，然后返回一个值。常见的表达式有下面几种情况：

1.  算术表达式：`1+2`是一个表达式，返回值是 3。甚至`3`本身也是一个表达式
2.  函数调用：`add(1, 2)`也是一个表达式，因为函数会返回一个值。
3.  宏调用
4.  用花括号包裹的最终返回一个值的代码块

### 语句块示例 ###

fn main() {
        
        // 这个语句块最后返回了temp - 1。
        // 注意这里的temp - 1后面没有分号。
        // 表达式最后不能有分号，一旦加上了分号，就会变成一个语句，而语句没有返回值。
        let result = {
        
            let temp = 10 * 3;
            temp - 1
        };
    }

### 返回值 ###

fn add(a: i32, b: i32) -> i32 {
        
        a + b
    }
    
    fn main() {
        
        let num1 = 5;
        let num2 = 7;
    
        let sum = add(num1, num2);
        println!("The sum of {} and {} is {}.", num1, num2, sum);
    }

> 使用 return

fn pass_exam(score: u32) -> bool {
        
        if score < 60 {
        
            return false;
        }
        true
    }

> 如果一个函数没有返回值，那么其实会隐式的返回一个单元类型`()`，类似 java 的 void 了！