由于一个学期没有碰Rust，相关知识殆已忘尽。最近各课逐渐停授，余出时间来从基础重温这些知识，也算是对没有写的基础知识的补充。另外这次复习主要参照了Youtube上的Crush Course视频，两个小时的视频一气看下来还是很累的啊。原视频链接
下载Rust，并在VSCode环境下使用
首先打开Rust官网，点击Get Started，下载对应的64位版本。运行下载程序并启用默认设置就可以。我的电脑里已经有旧版本，故只进行了更新操作。然后找到下载的bin文件夹路径添加环境变量即可，这个路径一般在users/YourName/.cargo/bin中
然后在VSCode的插件里搜索Rust，安装列表第一个插件即可。下面运行第一个小程序。
打开任意文件夹，创建一个文件Hello.rs，在里面输入如下代码：
fn main(){
println!("Hello, World!");
}在终端中输入rustc "Hello.rs"，正常编译后会在相同路径下出现对应的Hello.exe，运行时即在终端输出
> Hello, World!删除这些文件，在一个空文件夹里新建一个空工程。在终端输入如下指令：cargo init
Rust会为你自动生成一个完备的工程文件，包含一个Hello World程序。编译正常运行，到此基本配置已经结束。接下来就是Rust的一些基础使用方法。不过要指出的是这些内容并没有涉及到Rust的核心，也就是说几乎只是一个套皮的C、Python、Java或者其他语言的另一种写法。关于Rust的独到之处，还要进一步复习。在此只是记录备忘。
基本输出
把内容和参数打印到屏幕上可能是学习每门语言最先接触的东西了。Rust输出参数的时候会用到{}，是在哪里见过呢……
//原始形态
println!("Hello, world!");
//参数用{}标记
println!("Number: {}",1+2);
//{}中可加入指示位置的数字
println!("{1},{0},{2},{0}",
"Alice","Bob","Eve");
//{}中可加入参数名，不过要在参数列表处加以说明
println!("{name} stands by {num}",
name = "Bob",num = 1);
//格式化输出
println!("Binary:{:b} Hex:{:x} Oct:{:o}",10,10,10);
//{:?}可以输出元组，准确的说可以打印任何类型的具体信息。好像可以用来debug？
println!("{:?}",(12,true,"Hello"));
//参数列表可以进行简单的数学运算，这一点与C/C++等多数语言相同，不再赘述
定义变量
Rust中定义变量一般不需指明类型，而且默认是不可以改变其中的值的。要想改变需要额外添加mut字段。
let name = "Brad";
let age_1 = 20;
//age_1 = 21; //这里会报错，因为默认age_1是不可以改变的
let mut age = 20;
println!("I am {}",age); //输出20
age = 21;
println!("I am now {}", age); //输出21
println!("My name is {}", name);
//也可以定义常量
const ID:i32 = 001; //在变量名后面添加 :类型名 来指定类型
println!("My ID: {}",ID);
//可以一次定义多个变量
let (my_name, my_age) = ("Bob", 20);
println!("{} is {}", my_name, my_age);
基本类型
Rust中的一些基本类型见下：
整形用i/u + 数字(8/16/32/64/128) 表示 如u8,i64
浮点型有f32和f64两个类型
布尔型 bool
字符类型 Char
Tuples和Arrays
//普通整型默认为 "i32"类型
let x = 1;
//普通浮点数默认为"f64"类型
let y = 1.2;
//显式定义类型
let y:i64 = 123456789;
//显示Max size
println!("Max i32: {}", std::i32::MAX);
println!("Max i64: {}", std::i64::MAX);
//定义布尔值
let is_Act = true;
println!("{:?}",(x,y,is_Act));
//也可以从表达式获得bool值，不赘述*
//甚至可以用unicode保存emoji，格式为"\u{codeX}"
let face = '\u{1f600}';
println!("{}",face);
字符串类型
相似，不赘述
let mut hello = String::from("Hello!"); //声明一个可变字符串变量
println!("{}",hello);
//有判空、获得长度、获得占用空间、接续字符/字符串等类方法
println!("Length: {}",hello.len());
hello.push('!');
println!("{}",hello);
hello.push_str("???");
println!("{}",hello);
println!("cap:{}",hello.capacity());
println!("isEmpty:{}",hello.is_empty());
//可以匹配内部内容，如contain返回是否包含字段，replace返回替换指定内容的字符串(不改变原本内容)
println!("Contains \"Hello\"?: {}",hello.contains("Hello"));
println!("Contains \"World\"?: {}",hello.contains("World"));
println!("Replace: {}",hello.replace("llo", "LLO"));
hello = String::from("Hello world!");
for word in hello.split_whitespace(){
println!("{}",word);
}
//可以指定字符串所占的空间
let mut s = String::with_capacity(10);
s.push('a');
s.push('b');
//断言语句，不成立时投出panic
//assert_eq!(3,s.len()); //cause panic!
assert_eq!(2,s.len());
println!("{}",s);
tuple元组
元组是不同类型数据的集合，最多拥有十二个数据。
let person:(&str,&str,i8) = ("Brad","Mass",20);
println!("{} is from {} and is {}",person.0,person.1,person.2);
静态数组array
支持索引、切片。
//显式指定类型和长度
let mut numbers :[i32;5] = [1,2,3,4,5];
//let numbers :[i32;5] = [1,2,3,4]; //会报错-长度必须匹配
println!("{:?}",numbers);
//用索引得到单独的值
println!("{}",numbers[1]);
//对可变的数组可以对其中的值单独重新赋值
numbers[2] = 12;
println!("{:?}",numbers);
//求长度
println!("Array Len: {}", numbers.len());
//这里使用std::mem库获得占有空间大小
println!("Array occupies {} bytes",std::mem::size_of_val(&numbers));
//切片语法
let slc:&[i32] = &numbers[0..2];
println!("Slice:{:?}",slc);
动态数组vectors
和array类似，可以push和pop，用迭代器进行遍历
//只要明确类型
let mut numbers: Vec = vec![1,2,3,4];
//添加
numbers.push(5);
println!("{:?}",numbers);
//弹出首元素
numbers.pop();
println!("{:?}",numbers);
//用迭代器进行遍历
for x in numbers.iter(){
println!("Numbers: {}",x);
}
//用可变迭代器可以对内容进行修改
for x in numbers.iter_mut(){
*x *=2;
}
println!("Numbers Vec:{:?}",numbers);
逻辑结构
条件语句
let age = 15;
let gender:char = 'M';
//If-else
if age>=18 {
println!("Adult!");
} else {
println!("Not");
}
if age<=18 && gender=='M'{
println!("Boy");
}
//用if-else进行快速赋值，类似于?:表达式
let is_adult = if age >= 18 {true} else {false};
println!("An adult: {}", is_adult);
循环语句
let mut count = 0;
//最基本的loop循环，需要内部指明跳出条件
loop{
count += 1;
println!("Number: {}",count);
if count == 5{
break;}
}
//while循环，用法类似其他
while count <= 100{
if count % 15 == 0{
println!("Fuzzbuzz");
} else if count % 25 == 0{
println!("by 25");
} else if count % 5 == 0 {
println!("{}",count);
}
count += 1;
}
//for循环，遍历容器中的内容
for x in 0..20{
if x % 5 == 0 {println!("Go!{}",x);}
}函数调用
参数的声明以及返回值的书写比较值得注意，闭包的写法也要注意
pub fn run(){
greeting("Jane", "Hello");
println!("2+3={}",add(2,3));
//闭包可以使用外部的变量
let n3:i32 = 3;
let add_nums = |n1:i32, n2:i32| n1 + n2 + n3;
println!("Sum:{}",add_nums(1,2));
}
fn greeting(greet: &str, name: &str){
println!("{},{}!",greet,name);
}
fn add(n1:i32, n2:i32) -> i32 //类型在此声明
{
n1 + n2 //返回值后面没有分号
}引用指针
这里只是简单的介绍，还有很多内容没有写入
let arr1 = [1,2,3];
let arr2 = arr1;
println!("{:?}",arr1);
println!("{:?}",arr2);
//Array为原生类型，因此在这里无事发生
//非原生类型重新赋值时会导致赋值方不再保留原来的内容，出现所有权的移交
//这种情况下需要使用引用指针
let vec1 = vec![1,2,3];
let vec2 = &vec1; //使用了引用，vec1认为无事发生
//let vec2 = vec1; //这个语句会导致vec1不再拥有原来的数据
println!("Val:{:?}",(&vec1,vec2));结构体
比较特殊，从成员变量的声明到成员函数的加入。
//最基本的结构体，注意成员变量间用','分隔
struct Color {
red: u8,
green: u8,
blue: u8,
}
//元组的形式声明的结构体
struct Color2(u8,u8,u8);
//一个部署了成员方法的结构体，方法在后面用impl引出
struct Person{
first_name: String,
last_name: String,
}
impl Person{
//构造函数
fn new(first: &str, last: &str) -> Person{
Person{
first_name: first.to_string(),
last_name: last.to_string(),
}
}
fn full_name(&self) -> String{
format!("{} {}", self.first_name,self.last_name)
}
fn set_last_name(&mut self, last: &str){
self.last_name = last.to_string();
}
fn to_tuple(self) -> (String,String){
(self.first_name,self.last_name)
}
}
pub fn run(){
//最基本的初始化方法
let mut c = Color {
red: 255,
green: 0,
blue: 0,
};
//使用和修改时指明名称即可
println!("Color: {} {} {}",c.red,c.green,c.blue);
c.red = 200;
println!("Color: {} {} {}",c.red,c.green,c.blue);
//初始化元组结构体
let mut d = Color2(0,255,0);
//使用和修改时指明位置
println!("Color: {} {} {}",d.0,d.1,d.2);
//使用构造函数和其他成员函数
let mut p = Person::new("John", "Doe");
println!("Person {} {}",p.first_name,p.last_name);
println!("Person {}",p.full_name());
p.set_last_name("Williams");
println!("Person {}",p.full_name());
println!("{:?}",p.to_tuple());
}枚举类
枚举是只有具体的几个值的数据类型。具体值由编写者确定。
enum Movement{
Up, Down, Left, Right
}可以作为参数，也可以用match进行选择
fn move_avatar(m: Movement){
match m {
Movement::Up => println!("Avatar moving up"),
Movement::Down => println!("Avatar moving down"),
Movement::Left => println!("Avatar moving left"),
Movement::Right => println!("Avatar moving right"),
}//match类似于switch，注意用=>指向具体操作，之间用逗号分隔。
}
pub fn run(){
let avatar1 = Movement::Up;
let avatar2 = Movement::Down;
let avatar3 = Movement::Left;
let avatar4 = Movement::Right;
move_avatar(avatar2);
move_avatar(avatar3);
move_avatar(avatar1);
move_avatar(avatar4);
}以上介绍了Rust的基本写法。