系列文章目录
【跟小嘉学 Rust 编程】一、Rust 编程基础
【跟小嘉学 Rust 编程】二、Rust 包管理工具使用
【跟小嘉学 Rust 编程】三、Rust 的基本程序概念
文章目录
- 系列文章目录
- 前言
- 一、变量以及可变性
- 1.1、变量声明语法
- 1.2、不可变变量
- 1.3、未使用变量警告
- 1.4、使用 let mut 可变变量
- 1.5、使用 const 声明常量
- 1.6、Shadowing
- 1.7、暂时不使用的变量
- 1.8、全局常量和全局静态变量
- 1.8.1、全局常量
- 1.8.2、全局常量
- 二、数据类型
- 2.1、标量类型(Scalar Types)
- 2.1.1、整型(Integer Types)
- 2.1.1.1、几种整型类型
- 2.1.1.2、整型字面量(Integer Literals)
- 2.1.1.3、整数溢出
- 2.1.2、浮点型(Floating-Point Types)
- 2.1.3、布尔类型(Boolean Type)
- 2.1.4、字符(Character Type)
- 2.1.5、数字操作
- 2.2、复合类型(Compound Types)
- 2.2.1、元组(Tuple Type)
- 2.2.1.1、元组定义
- 2.2.1.2、访问元组的方式
- 2.2.1.2.1、模式解构
- 2.2.1.2.2、数字索引(使用`.`来访问元组)
- 2.2.2、数组(Array Type)
- 2.2.2.1、数组的定义
- 2.2.2.2、数组的访问
- 三、函数
- 3.1、函数定义
- 3.2、函数参数(parameters)
- 3.3、返回值(Return Values)
- 3.4、语句和表达式(Statements and Expressions)
- 3.4.1、语句
- 3.4.1.1、赋值语句
- 3.4.1.2、代码块
- 3.4.2、表达式
- 四、注释(Comments)
- 五、控制流(Control Flow)
- 5.1、if 表达式
- 5.1.1、if else 表达式
- 5.1.2、在let语句中使用 if
- 5.2、循环(loops)
- 5.2.1、loop 循环
- 5.2.1.1、loop 死循环
- 5.2.1.2、loop 循环返回值
- 5.2.1.2、loop 标签结合break 来跳出指定循环
- 5.2.2、while 循环
- 5.2.2.1、while 循环
- 5.2.2.2、使用 while 循环遍历数组
- 5.2.3、for 循环
- 5.2.3.1、遍历序列
- 5.2.3.2、迭代器循环
- 5.2.3.3、数组遍历
- 总结
前言
本章节涵盖几乎所有编程语言会出现的概念以及他们在 Rust之中的工作原理,这不是 Rust 独有的,但我们将在 Rust 上下文中讨论他们,并且解释这些概念。详细来讲就是变量、基本类型、函数、注释和控制流。
主要教材参考 《The Rust Programming Language》
一、变量以及可变性
1.1、变量声明语法
let [mut] variableName[:type] [= initialValue]
- 变量必须先声明在使用
- rust 没有默认构造函数,变量没有默认值;
- variableName 以字母(unicode)、下划线、数字组成,但是必须以字母(unicode)、下划线开头;
- 未声明类型的为自动类型推导,但不意味着动态类型。
1.2、不可变变量
默认情况下,变量是不可变的,这是 Rust 提供的用于安全性和简单并发性方式编写代码。
例子:不可变变量
fn main() {let x = 5;println!("The value of x is: {x}");x = 6;println!("The value of x is: {x}");}
错误提示
raojiamin@192 hello % cargo build Compiling hello v0.1.0 (/Users/raojiamin/Desktop/code/rust_code/hello)error[E0384]: cannot assign twice to immutable variable `x` --> src/main.rs:4:5|2 | let x = 5;| -| || first assignment to `x`| help: consider making this binding mutable: `mut x`3 | println!("The value of x is: {x}");4 | x = 6;| ^^^^^ cannot assign twice to immutable variableFor more information about this error, try `rustc --explain E0384`.error: could not compile `hello` (bin "hello") due to previous error
初始化本身可以依赖变量,可能多次调用它所在函数可能得到不同的值;
1.3、未使用变量警告
如果你声明了变量但是并未使用,编译器则会给你一个变量未使用的警告。
warning: unused variable: `x` --> src/main.rs:2:9|2 | let x = 5;| ^ help: if this is intentional, prefix it with an underscore: `_x`|= note: `#[warn(unused_variables)]` on by defaultwarning: `hello` (bin "hello") generated 1 warning (run `cargo fix --bin "hello"` to apply 1 suggestion)Finished dev [unoptimized + debuginfo] target(s) in 0.89s
1.4、使用 let mut 可变变量
fn main() {let mut y = 100; // help: maybe it is overwritten before being read" />// 如果在第二次赋值前没有读取该变量会有上述警告println!("the y value is {}", y);y = 100; println!("the y value is {}", y);}
1.5、使用 const 声明常量
初始化过程完全静态(编译器时期已知其值),且不会改变。
fn main() {const X:i32 = 100;// warning: constant is never used: `x` 警告:常量必须被使用// warning: constant `x` should have an upper case name 常量必须大写// error: missing type for `const` item 错误:常量必须声明类型println!("the X value is {}", X); }
const 常量一定不能 使用 mut 修饰。
1.6、Shadowing
该特性可以反复声明不可变对象,她可以重新更改不可变变量的数据类型,该语法特性一般用于中间变量。
fn main() {let x = 5;let x = x + 1;let x = x * 2;println!("The value of x is: {}", x);}
该特性不允许使用在可变对象上。
fn main() {let mut spaces = " ";spaces = spaces.len();}
错误提示
cargo build Compiling hello v0.1.0 (/Users/raojiamin/Desktop/code/rust_code/hello)error[E0308]: mismatched types --> src/main.rs:3:14|2 | let mut spaces = " ";|----- expected due to this value3 | spaces = spaces.len();|^^^^^^^^^^^^ expected `&str`, found `usize`|help: try removing the method call|3 - spaces = spaces.len();3 + spaces = spaces;|For more information about this error, try `rustc --explain E0308`.error: could not compile `hello` (bin "hello") due to previous error
1.7、暂时不使用的变量
fn main() {let _ = "hello";let _num = 100; // 表示可暂时不使用该变量println!("{}", _);// 编译错误!“_” 的含义是忽略该变量绑定,之后不会再用了}
以下划线开头的变量名,如 ”_num“, 表示可以暂时不使用该变量;
1.8、全局常量和全局静态变量
在Rust 之中没有全局变量的概念,但是可以使用全局静态变量和全局常量。
1.8.1、全局常量
- 全局常量必须在声明的时候初始化;
- 全局常量名必须大写
- 全局常量必须在声明的时候显示声明类型;
1.8.2、全局常量
- 静态变量必须在声明时初始化;
- 静态变量必须编译时可确定的常量, 变量名必须大写;
- mut 修饰的静态变量,使用的时候必须 unsafe 函数或者 unsafe 代码块;
- 静态变量在声明时候必须指定静态的变量的数据类型;
二、数据类型
2.1、标量类型(Scalar Types)
标量类型表示单个值。Rust 中有四种主要的标量类型:整型、浮点型、布尔类型、字符。
2.1.1、整型(Integer Types)
2.1.1.1、几种整型类型
整型数据默认是 i32 类型, isize 或 usize 在 32 位机器上就是 4 个字节,在 64 位机器上就是 8 个字节。
Length | Signed | Unsigned| |
---|---|---|
8-bit | i8 | u8 |
16-bit | i16 | u16 |
32-bit | i32 | u32 |
64-bit | i64 | u64 |
128-bit | i128 | u128 |
arch | isize | usize |
每一个变量都可以是有符号或无符号,并且具有明确的大小,有符号数使用二进制补码来表示存储。(早期8086 cpu只支持加法指令)
- 原码:最高位为符号位,0代表正数,1代表负数,其余各位为数值本身的绝对值
- 反码:
- 正数:反码与原码相同,这是规定;
- 负数:符号位为1不变,其余位对原码取反;
- 补码:
- 正数:补码与原码相同
- 负数:符号位为1不变,其余位对原码取反加1;
isize 和 usize的主要场景是对某种集合进行索引操作。
2.1.1.2、整型字面量(Integer Literals)
Number literals | Example | |
---|---|
Decimal | 98_222 |
Hex | 0xff |
Octal | 0o77 |
Binary | 0b1111_000 |
Byte(u8 only) | b’a’ |
除了byte类型外,所有数值字面量都允许使用类型后缀,例如:67u8;
2.1.1.3、整数溢出
u8的范围是0-255,如果你把一个 u8的值设置为 256。
- 调试模式(Debug)下,rust 会检查整数溢出,如果发生溢出,程序会在运行时就会 panic。
- 发布模式(Release)下,rust 不会检查整数溢出,若果发生溢出,rust 会执行环绕操作,不会抛出 panic;
如果要在 release 模式下打开整数溢出检查后,只需要在 Cargo.toml 中配置
[profile.release]overflow-checks = true
2.1.2、浮点型(Floating-Point Types)
浮点数有两种类型:f32(单精度)、f64(双精度)。Rust的浮点类型使用了 IEEE-754 标准来表述。 f64 是默认类型,因为在现代 CPU 上 f64 和 f32 的速度差不多,而且精度更高。
2.1.3、布尔类型(Boolean Type)
布尔类型只有两个值:true、false。布尔类型的大小为1 字节,在 rust 中 布尔类型使用 bool 关键字。
2.1.4、字符(Character Type)
字符类型是一个比较特别的,在 Java 和 CPP 之中 都只占用 1个字节,但是 Rust 为了支持描述任何一个 unicode 字符, char 类型需要 4个字节来描述,这样会带来空间资源的浪费,因为 ASCII 字符其实只需要 1 个字节的空间。如果只需要单字节即可,Rust 给出的解决方案是用 ‘b’ 来声明单字节,将字符以u8类型的形式存储。
let x: u8 = b'A';// 占 1 个字节let y: char = 'A'; // 占 4 个字节
2.1.5、数字操作
Rust 支持所有数字类型所需要的基本数学操作:+、-、*、/、% 。 整数触发会向零截断到最接近的整数。
fn main() {// additionlet sum = 5 + 10;// subtractionlet difference = 95.5 - 4.3;// multiplicationlet product = 4 * 30;// divisionlet quotient = 56.7 / 32.2;let truncated = -5 / 3; // Results in -1// remainderlet remainder = 43 % 5;}
2.2、复合类型(Compound Types)
复合类型可以将多个值分组到一个类型中,Rust 中有两种基本复合类型:元组和数组。
2.2.1、元组(Tuple Type)
元组是一个具有多种数据类型的多个值组合成一个复合类型,元组有固有的长度。一旦声明它们的长度就不会增长或缩小。
2.2.1.1、元组定义
我们通常在括号内写一个逗号分隔的值列表来创建元组。
fn main() {let tup:(i32, f64, u8) = (500, 6.4, 1);// 定义空元组let tup01:() = ();// 单个元素元组let tup02 = (1,);println!("{:?}", tup01);println!("{:?}", tup02);println!("{:?}", tup);}
需要注意:
- 如果你使用显示数据类型声明单个元素的元组,编译器会给出警告;
- 如果你要声明单个元素,必须使用自动类型推断,并且初始化的时候必须带有逗号,否则会被编译器认为是单个元素变量;
2.2.1.2、访问元组的方式
2.2.1.2.1、模式解构
fn main() {let tup:(i32, f64, u8) = (500, 6.4, 1);let (x, y, z) = tup;println!("{:?}", tup);println!(" the value of x is :{}", x);println!(" the value of y is :{}", y);println!(" the value of z is :{}", z);}
2.2.1.2.2、数字索引(使用.
来访问元组)
模式解构可以让我们一次性把元组全部获取出来,如果我们想要访问某个元组, 可以使用 . 操作符来访问;和其他语言一样 数组、字符串、元组的索引从0开始。
fn main() {let x: (i32, f64, u8) = (500, 6.4, 1);let five_hundred = x.0;let six_point_four = x.1;// 如果索引不在范围内,会报如下错误 error[E0609]: no field `3` on type `(i32, f64, u8)`println!("five_hundred is {}", five_hundred);println!("six_point_four is {}", six_point_four);}
2.2.2、数组(Array Type)
数组的每个元素都必须具有相同的类型,数组具有固定的长度,依次线性排列。
2.2.2.1、数组的定义
数组的定义格式如下:let 变量名[类型; 数组长度] = [初始化列表];
fn main() {let array:[i32; 3] = [1,3,5];let months = ["January", "February", "March", "April", "May", "June", "July","August", "September", "October", "November", "December"];// 如果一个数组有多个重复的元素的时候let a = [3;5];println!("array: {:?}", array);println!("months: {:?}", months);}
2.2.2.2、数组的访问
使用索引访问数组的元素,索引从0开始,到数组长度-1;如果超出数组索引访问将会运行时报错。
fn main() {let a = [9, 8, 7, 6, 5];let first = a[0]; // 获取a数组第一个元素let second = a[1]; // 获取第二个元素println!("first: {:?}", first);println!("second: {:?}", second);}
索引越界的时候,程序将会执行错误
error: this operation will panic at runtime --> src/main.rs:5:18|5 | let second = a[6]; // 获取第二个元素|^^^^ index out of bounds: the length is 5 but the index is 6|= note: `#[deny(unconditional_panic)]` on by defaulterror: could not compile `hello` (bin "hello") due to previous error
三、函数
函数在Rust代码只能够很常见,我们已经见到了最重要的函数 main 函数,他是许多程序的入口函数,我们还看到了 fn 关键字。
3.1、函数定义
在 rust 里面函数使用 fn 关键字声明。rust中函数名采用所有字母都是小写的,并且使用下划线分隔单词。函数使用大括号包括起来。
// 无参函数fn another_function() {println!("Another function.");}
3.2、函数参数(parameters)
// 函数参数,函数的参数必须声明参数的类型fn another_function(x: i32) {println!("Another function.");}
- 定义函数的时候声明的参数叫做形式参数;
- 调用函数的时候传入的参数叫做实际参数;
3.3、返回值(Return Values)
// 函数返回值fn five() -> i32 {println!("Another function.");return 5; //或者直接写 5}
在 rust 里面,函数可以在函数里面定义,也可以在函数外面定义。
函数里包含了语句和表达式。在rust语言里面。函数定义也是语句,所以函数可以在函数内部定义。
需要注意的是我们在省略 return 关键字的时候,不能带有分号,否则会报错
error[E0308]: mismatched types --> src/main.rs:7:24|7 | fn plus_one(x: i32) -> i32 {|--------^^^ expected `i32`, found `()`|||implicitly returns `()` as its body has no tail or `return` expression8 | x + 1;|- help: remove this semicolon to return this value
3.4、语句和表达式(Statements and Expressions)
函数体是由一些语句组成,可选地以表达式结尾。
3.4.1、语句
执行某些操作但不返回值的指令
3.4.1.1、赋值语句
let y = 6;
let 语句不能作为赋值语句的右值。
3.4.1.2、代码块
fn main() {let y = {let x = 3;x + 1};println!("The value of y is: {y}");}
3.4.2、表达式
表达式求值为结果值。
四、注释(Comments)
所有程序员都努力使它们的代码易于理解,但是有时候额外的解释是必要的,编译器会忽略这些注释。
五、控制流(Control Flow)
5.1、if 表达式
if 表达式 允许根据条件对代码进行分支选择,如果条件满足,则运行,否则不运行。
if 后面必须得更 bool 类型变量或表达式,否则将会报错
error[E0308]: mismatched types --> src/main.rs:4:8|4 | if number {|^^^^^^ expected `bool`, found integer
5.1.1、if else 表达式
1、双分支结构
fn main() {let number = 3;if number < 5 {println!("condition was true");} else {println!("condition was false");}}
2、多分枝结构
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");}}
5.1.2、在let语句中使用 if
在 let 语句右边可以使用 if 表达式,但是要求两个分支的值要是相同的类型,否则将会报错
fn main() {let condition = true;let number = if condition { 5 } else { 6 };println!("The value of number is: {number}");}
5.2、循环(loops)
5.2.1、loop 循环
5.2.1.1、loop 死循环
fn main() {loop {println!("again!");}}
5.2.1.2、loop 循环返回值
fn main() {let mut counter = 0;let result = loop {counter += 1;if counter == 10 {break counter * 2;}};println!("The result is {result}");}
5.2.1.2、loop 标签结合break 来跳出指定循环
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}");}
5.2.2、while 循环
5.2.2.1、while 循环
fn main() {let mut number = 3;while number != 0 {println!("{number}!");number -= 1;}println!("LIFTOFF!!!");}
5.2.2.2、使用 while 循环遍历数组
fn main() {let a = [10, 20, 30, 40, 50];let mut index = 0;while index < 5 {println!("the value is: {}", a[index]);index += 1;}}
5.2.3、for 循环
5.2.3.1、遍历序列
fn main() {for i in 1..11{println!("{}", i);}}
其中 1…11 是 Range 对象的定义形式,表示的是1-10 的序列;
fn main() {for number in (1..4).rev() {println!("{number}!");}println!("LIFTOFF!!!");}
5.2.3.2、迭代器循环
fn main(){let fruits=["mango","apple","banana","litchi","watermelon"];for fruit in fruits.iter(){print!("{:?} ",fruit);}}
5.2.3.3、数组遍历
fn main() {let a = [10, 20, 30, 40, 50];for element in a {println!("the value is: {element}");}}
总结
以上就是今天要讲的内容
- 本文介绍了 Rust 基本程序概念,主要包含 Rust 变量和常量的定义使用、Rust 数据类型、Rust 流程控制;