文章目录
- 变量
- 可变与不可变变量
- 变量与常量
- 变量的Shadowing
- 标量类型
- 整数
- 复合类型
- 函数
- 控制流
- if else
- loop & while
- for in
- struct
- struct的定义
- Tuple Struct
- struct的方法与函数
变量
可变与不可变变量
Rust中使用let来声明变量,但是let声明的是不可变变量,如果想要可变,则需要加上mut关键字
fn main(){let x = 10;x = x + 1; //报错,因为x是不可变类型let mut y = 11;y = y + 1; //可行
}
变量与常量
常量与不可变变量一样都是不能被修改的,但是他与不可变变量有很多区别。
- 常量用const声明,且必须标注其类型
- 常量不能加mut修饰
- 常量可以在任何作用域内声明(包括全局)
- 常量只可以绑定在常量表达式中,无法绑定在函数的调用结果或者只能在运行时才能计算出的值。
- 在场许运行期间,长廊在其作用域内一直有效。
常量命名规范:全大写字母+下划线分割(不符合规范rust编译器会警告)
const MAX_POINT = 10000;
fn main(){
}
变量的Shadowing
Rust允许用户在一个作用域内重复的声明一个同名变量,并且可以是不同的类型的,而后声明的变量会覆盖前面声明的变量,这叫做变量的shadowing
fn main(){let x = 100;let x = "Test"; // 此时在对x进行操作,x的值就是"Test"let number = "123123";let number = number.trim().parse(); //转化为数字//上述shadowing就使得通用一个number的变量名,但是却做到了类型转换。
}
标量类型
Rust是一个强类型的静态语言,这意味着在编译时编译器就需要明确的知道每个变量的类型,而不是像Py一样,“变量的类型是动态可变的”。
而上述的代码没有指定类型,只使用了let,是因为Rust的编译器可以自行推断出变量的类型(根据返回值,上下文,调用情况)。而有时情况过于复杂时便无法推断,便需要使用者自行标注出类型。
整数
整数类型如下:
可以看到分类无符号和有符号类型,并且每个类型都标清楚了占多少字节,最后一个isize类型表示的是CPU位数长度的整数类型(一个机器字长),与电脑硬件有关。
如下面代码所示,在变量后面加冒号在家类型就可以强制显示的的表明变量的类型。
fn main(){let x: i8 = 18;let y: u32 = 100;
}
整数字面值如上:
Rust允许在数字之间加下划线用于增加可读性。其中十六进制以0x开头,八进制以0o开头,二进制以0b开头。
而字节类型需要在字符串前加一个b。
Rust允许在数值后面加上类型来标注这个数字的类型
fn main(){let x = 1002u32let y = 10010010i32let z = 0b100100let a = 0xffa0let b = b'B'
}
Rust的int默认值是32,浮点数默认值是64Bytes。如果整数类型发生了溢出,那么程序就会panic,如果在发布模式下编译则不会检查溢出。Rust的溢出会进行环绕操作,即对可取的最大值取余。
布尔类型则是有两个值,一个是true,一个是false占两个字节
fn main(){let x: bool = true;
}
字符类型用来描述语言中最基础的单个字符,占四个字节,使用的值是Unicode表值。
fn main(){let x: char = '你';let u: char = '🙂';
}
复合类型
Rust提供了两种复合类型,一个是Tuple,一种是数组。
Tuple的创建遵循以下规则:
fn main(){let x: (i32, char, f32) = (2003, 'a', 0.3);println!("{} {} {}", x.0, x.1, x.2);
}
对于元组可以使用点+索引的形式来得到元素,元组是定长的,你可以认为它类似于C的struct的简化版。
元组还可以进行拆包,其过程如下:
fn main(){let x: (i32, char, f32) = (2003, 'a', 0.3);let (a, b, c ) = x;
}
另一个数据类型,数组则是定长,且使用[]来进行定义和创建
fn main(){let x: [i32; 5] = [1, 2, 3, 4, 5]; // 创建一个i32类型,长度为5的数组let y = [5; 4];// 创建4个i32类型值为5,长度为4的数组let z = ["xxx", "yyy"]; //创建两个str类型的数组
}
上述需要注意的是let y = [5; 4];这种写法相当于是创建一个重复为5,长度为4的数组
函数
rust的函数的格式为:
fn 函数名(参数: 类型) -> 返回值{函数体;
}
fn main(){let x = test();
}fn test(){println!("Test");
}
上述的test的返回值是()。
fn main(){let _x = test(32);
}fn test(number: i32) -> (){println!("Test number is {}", number);
}
Rust的函数体由Statement和Expression来构成,其中Statement指的是像let x = 10;这类的语句,而Expression则是x + 3, x == 5这样具有返回值的表达式。
Rust默认最后一个表达式即为返回值(或者函数题的值),如果没有则默认值为()
fn main(){let x = test(10);println!("Test number is {}", x);
}fn test(number: i32) -> i32{5 + number //注意,5 + number后面没有分号,否则将会被视为一个语句
}
这个函数体还可以作为变量的值来传递
fn main(){let x = {let mut _y = 11;_y * 3};println!("{}", x)
}
上述x的的值是33,如果函数体最后一个语句没有返回值,则会得到()
控制流
与Rust控制流相关的有loop,while,for in的循环语句和if else,match的判断语句。其中match涉及到枚举不在这里记录,放在枚举那里。
if else
if和else就类似于C语言,当只有一个单独的语句时可以不用最外层的括号
fn main(){let x = 10;if x > 5 {println!("大于5");}else if x == 5 {println!("小于5");}else {println!("小于5");}
}
三元运算符,有点类似于python与C的结合体,例子如下
if 条件 {结果1} else {结果2}
fn main(){let x = if 5 > 3 {5} else {3};println!("x is {}", x);let y = if x != 5 {x * 2}else{x - 3};println!("y is {}", y);
}
/*Compiling hello_world v0.1.0 (E:\RustProject\Hello_World)Finished dev [unoptimized + debuginfo] target(s) in 0.69sRunning `target\debug\hello_world.exe`
x is 5
y is 2
*/
loop & while
loop的用法就是相当于while true,也就是loop内的语句会被不停地循环,直到遇到break为止。
用法如下:
fn main(){let mut x = 0;loop{x += 1;if x > 10{break;}}println!("x is {}", x);
}
而对于while循环则是和C和Py一样,break和continue语句也是同样的道理。
while 条件{}
fn main(){let mut x = 0;while x <= 10 {x += 1;}println!("x is {}", x);
}
for in
for in则是类似于py的for in集合的模式,in后面需要跟一个可以迭代的类型例如数组。
需要注意的是此时tmp是&i32类型,也就是说它的类型是确定的,没法for in一个多种类型的Tuple。
fn main(){let x = [3, 4, 5, 6];for tmp in x.iter(){ //iter方法得到x的迭代器println!("{}", tmp);}
}
/*Compiling hello_world v0.1.0 (E:\RustProject\Hello_World)Finished dev [unoptimized + debuginfo] target(s) in 1.07sRunning `target\debug\hello_world.exe`
3
4
5
6
*/
对于计数之类的需求,Rust提供了Range的方法,可以使用a…b来构造一个a+1,a+2…, b-2, b-1的序列来进行遍历,如下:
fn main(){for x in 3..10{println!("{}", x);}
}
/*Compiling hello_world v0.1.0 (E:\RustProject\Hello_World)Finished dev [unoptimized + debuginfo] target(s) in 1.03sRunning `target\debug\hello_world.exe`
3
4
5
6
7
8
9
*/
struct
struct的定义
Rust的struct定义如下:
struct 名称{
变量1: 类型,
变量2: 类型…
}
struct Rectangle{width: u32,length: u32
}
而struct的初始化则是使用名字+变量名:值的形式初始化,注意,struct不允许有字段为空值,也就是说需要全部值都初始化
let re = Rectangle{width: 10,length: 19};
而这些值的访问就类似于C的struct,直接用点+对应的字段即可。
struct也可以设置为mut,而对于struct来说,一旦设置为mut,则里面每个值都必须要是mut,也就是说都是可变的。
let mut re = Rectangle{width: 10,length: 19};re.width = 100;
当有变量名与struct内部定义的变量名同名时,可以省去冒号进行初始化
struct Rectangle{width: u32,length: u32
}fn main(){let width = 9;let mut re = Rectangle{width, // 省去了冒号,因为width同名length: 19};
}
当想要对struct进行更新时,有一种简单的简写操作,如下:
let width = 9;let mut re = Rectangle{width, length: 19};let re2 = Rectangle{width: 100,..re //re表示,剩下的字段的值与re的剩余字段的值相同};
Tuple Struct
struct的方法与函数
对于一个struct,它拥有对应的方法和函数,而对于方法则是应用于struct的上下文中的,可以获取和修改具体的struct的值。而函数则不能,他只是与某种struct关联到了一起而已。
使用impel关键字来为struct绑定方法和函数。
第一个参数带有self关键字就是方法,而不带有则是函数
struct Rectancle{width: u32,length: u32,
}impl Rectancle {//为Rectangle绑定函数和方法fn area(&self) -> u32{//绑定一个方法&self表示Rectangle结构体本身self.width * self.length //返回面积}
}fn main(){let y = Rectancle{width: 10,length: 15};println!("Area is {}", y.area());
}
下面是绑定一个函数例子
struct Rectancle{width: u32,length: u32,
}impl Rectancle {fn area(&self) -> u32{self.width * self.length}fn make_square(size: u32) -> Rectancle { //构造一个正方形Rectancle { width: (size), length: (size) }}
}fn main(){let sq = Rectancle:: make_square(10);//通过使用::的方式来调用函数println!("Area is {}", sq.area());
}
需要注意,每个struct允许拥有多个impel的模块。