文章 标签 分类 关于 工具箱

Contents

rust通用编程概念

zhangyuhu included in rust
   2159 words   5 minutes 

本文采用知识共享署名 4.0 国际许可协议进行许可，转载时请注明原文链接，图片在使用时请保留全部内容，可适当缩放并在引用处附上图片所在的文章链接。

Rust 程序设计语言 中文版

关键字

  • as - 强制类型转换，消除特定包含项的 trait 的歧义，或者对 use 和 extern crate 语句中的项重命名
  • async - 返回一个 Future 而不是阻塞当前线程
  • await - 暂停执行，直到 Future 的结果准备好
  • break - 立刻退出循环
  • const - 定义常量或不变裸指针（constant raw pointer）
  • continue - 继续进入下一次循环迭代
  • crate - 链接（link）一个外部 crate 或一个代表宏定义的 crate 的宏变量
  • dyn - 动态分发 trait 对象
  • else - 作为 if 和 if let 控制流结构的 fallback
  • enum - 定义一个枚举
  • extern - 链接一个外部 crate 、函数或变量
  • false - 布尔字面量 false
  • fn - 定义一个函数或 函数指针类型 (function pointer type)
  • for - 遍历一个迭代器或实现一个 trait 或者指定一个更高级的生命周期
  • if - 基于条件表达式的结果分支
  • impl - 实现自有或 trait 功能
  • in - for 循环语法的一部分
  • let - 绑定一个变量
  • loop - 无条件循环
  • match - 模式匹配
  • mod - 定义一个模块
  • move - 使闭包获取其所捕获项的所有权
  • mut - 表示引用、裸指针或模式绑定的可变性
  • pub - 表示结构体字段、impl 块或模块的公有可见性
  • ref - 通过引用绑定
  • return - 从函数中返回
  • Self - 实现 trait 的类型的类型别名
  • self - 表示方法本身或当前模块
  • static - 表示全局变量或在整个程序执行期间保持其生命周期
  • struct - 定义一个结构体
  • super - 表示当前模块的父模块
  • trait - 定义一个 trait
  • true - 布尔字面量 true
  • type - 定义一个类型别名或关联类型
  • unsafe - 表示不安全的代码、函数、trait 或实现
  • use - 引入外部空间的符号
  • where - 表示一个约束类型的从句
  • while - 基于一个表达式的结果判断是否进行循环

变量和可变性

immutable & immutable

不可变的（immutable），可变的（immutable）。

1
2
3
4
5
6

fn main() {
    let mut x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

常量

常量（constant）是绑定到一个常量名且不允许更改的值。

1

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

遮蔽

遮蔽（shadow）：以声明和前面变量具有相同名称的新变量，这意味着当我们使用变量时我们看到的会是第二个变量的值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {}", x);
    }

    println!("The value of x is: {}", x);
}

mut 和遮蔽之间的另一个区别是，因为我们在再次使用 let 关键字时有效地创建了一个新的变量，所以我们可以改变值的类型，但重复使用相同的名称。

1
2

let spaces = "   ";
let spaces = spaces.len();

数据类型

Rust 是一种静态类型（statically typed）的语言，这意味着它必须在编译期知道所有变量的类型。

1

let guess: u32 = "42".parse().expect("Not a number!");

标量类型

标量（scalar）类型表示单个值。Rust 有 4 个基本的标量类型：整型、浮点型、布尔型和字符。

  • 整型
长度 有符号类型 无符号类型
8 位 i8 u8
16 位 i16 u16
32 位 i32 u32
64 位 i64 u64
128 位 i128 u128
arch isize usize
  • 整型字面量
数字字面量 示例
十进制 98_222
十六进制 0xff
八进制 0o77
二进制 0b1111_0000
字节 (仅限于 u8) b'A'

  • 浮点型

    Rust 的浮点型是 f32 和 f64，它们的大小分别为 32 位和 64 位。默认浮点类型是 f64，因为在现代的 CPU 中它的速度与 f32 的几乎相同，但精度更高。所有浮点型都是有符号的。

  • 数字运算

    Rust 的所有数字类型都支持基本数学运算：加法、减法、乘法、除法和取模运算。整数除法会向下取整。

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

    fn main() {
    // addition
    let sum = 5 + 10;

    // subtraction
    let difference = 95.5 - 4.3;

    // multiplication
    let product = 4 * 30;

    // division
    let quotient = 56.7 / 32.2;
    let floored = 2 / 3; // Results in 0

    // remainder
    let remainder = 43 % 5;
}

  • bool

    1

    let f: bool = false;

  • char

    1

    let c = 'z';

复合类型

Rust 有两种基本的复合类型：元组（tuple）和数组（array）。

1
2
3
4
5
6
7

let tup: (i32, f64, u8) = (500, 6.4, 1);
let a = [1, 2, 3, 4, 5];
let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];

let a: [i32; 5] = [1, 2, 3, 4, 5]; // i32 是每个元素的类型。分号之后，数字 5 表明该数组包含 5 个元素。
let a = [3; 5]; // 变量名为 a 的数组将包含 5 个元素，这些元素的值初始化为 3。

函数

Rust 中的函数定义以 fn 开始，后跟着函数名和一对圆括号。大括号告诉编译器函数体在哪里开始和结束。

  • 参数
1
2
3
4
5
6
7

fn main() {
    another_function(5);
}

fn another_function(x: i32) {
    println!("The value of x is: {}", x);
}
  • 语句和表达式 语句（statement）是执行一些操作但不返回值的指令。表达式（expression）计算并产生一个值
1
2
3
4
5
6
7
8

fn main() {
    let y = {
        let x = 3;
        x + 1 // 注意，x + 1 行的末尾没有分号，这与你目前见过的大部分代码行不同。表达式的结尾没有分号。如果在表达式的末尾加上分号，那么它就转换为语句，而语句不会返回值。
    };

    println!("The value of y is: {}", y);
}
  • 带有返回值的函数
1
2
3
4
5
6
7
8
9

  fn five() -> i32 {
      5
  }

  fn main() {
      let x = five();

      println!("The value of x is: {}", x);
  }

控制流

if

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }

    let condition = true;
      let number = if condition { 5 } else { 6 };

      println!("The value of number is: {}", number);
}

循环

Rust 有三种循环：loop、while 和 for。

  • loop

    loop 关键字告诉 Rust 一遍又一遍地执行一段代码直到你明确要求停止。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

  fn main() {
      let mut count = 0;
      'counting_up: loop {
          println!("count = {}", count);
          let mut remaining = 10;

          loop {
              println!("remaining = {}", remaining);
              if remaining == 9 {
                  break;
              }
              if count == 2 {
                  break 'counting_up;
              }
              remaining -= 1;
          }

          count += 1;
      }
      println!("End count = {}", count);
  }

从循环返回

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

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

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

  • while

    在程序中计算循环的条件也很常见。当条件为真，执行循环。当条件不再为真，调用 break 停止循环。这个循环类型可以通过组合 loop、if、else 和 break 来实现.

  • for

1
2
3
4
5
6
7

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

      for element in a {
          println!("the value is: {}", element);
      }
  }
Updated on 2023-01-19
 rust
Back | Home