2022最新Rust变量与数据类型讲解

let x :i8 =1
let x = 1 ; // 等价于 let x: i32 = 1;

let mut x = 3;
x = 5;
println!("x: {}",x);

fn main(){
    let x = 3;
    let x = x+2;
    let x = x*2;
    let x = "Hello, World";
}

const MAX_NUM : u32 = 1024;

let integer1 : u32 = 17 ; // 类型声明
let integer2 = 17u32;     // 类型后缀声明
let integer3 = 17 ;       // 默认i32
let integer4 : u32 = 0b1001; // 二进制
let integer5 : u32 = 0o21;   // 八进制
let integer6 : u32 = 0x11 ;  // 十六进制
let integer7 = 50_000;   // 数据可读性分隔符_

let float1 : f32 = 1.1;  // 类型声明
let float2  = 2.2f32;  // 类型后缀声明
let float3 = 3.3  ;  // 默认f64类型
let float4 = 11_00.555_01;  // 数字可读性分隔符

let t : bool = true;  //显式类型声明
let f = false ;       // 隐式类型声明

let z = 'z' ;  // 使用单引号
let hz = '中';

fn main(){
    print!("(1..5):")
    for i in 1..5 {
        print!("{} ",i);
    }
    println!();
    
    print!("(1..=5).rev:");
       for i in (1..=5).rev() {
        print!("{} ",i);
    }
    println!();
    
    let sum :i32 = (1..=5).sum();
    println!("sum(1..=5)={}",sum);
}

//(1..5):1 2 3 4 
//(1..=5).rev:5 4 3 2 1 
//sum(1..=5)=15

let tup1 :(i8,f32,bool) = (-10,7.7,false);
let tup2 = (7.7,(false,10));
let tup3 = (100,);
println!("{},{}",tup1.0,tup2.1)
// 解构赋值
let (x,y,z) = tup1;

// 指定数组类型，为每一个元素赋值
let arr:[i32;5] = [1,2,3,4,5];
// 省略数组类型 --> 编译器可以从初始值推断出数组类型
let arr = [1,2,3,4];
// 省略数组类型，为所有元素使用默认值初始化
let arr = [1;5]; // -> 等价let arr = [1,1,1,1,1]

// 指定数组类型，为每一个元素赋值
let arr:[i32;5] = [1,2,3,4,5];
// 省略数组类型 --> 编译器可以从初始值推断出数组类型
let arr = [1,2,3,4];
// 省略数组类型，为所有元素使用默认值初始化
let arr = [1;5]; // -> 等价let arr = [1,1,1,1,1]

struct Student {
    name : &'static str,
    score: i32,
}

fn main(){
    let score = 59;
    let username = "wkk";
    
    let mut student = Student{
        score, // 变量和字段同名，可以简写
        name : username,
    };
    
    student.score = 60;
    //结构体更新语法，对除字段name外未显式设置值的字段以student实例对应字段的值来赋值。
    let student2 = Student {
        name : "yyr",
        ..student
    };
}

struct Color(i32,i32,i32);

struct Solution;

// #[derive(Debug)] 让ColorNoParam自动实现Debug trait
// 只有实现了Debug trait的类型才拥有使用{:?}格式化打印的行为
#[derive(Debug)]
enum ColorNoParam {
	Red,
    Yellow,
    Blue,
}

fn main(){
    let color_no_param = COlorNoParam::Red;
    match color_no_param{
		ColorNoParam :: Red => println!("{:?}",ColorNoParam::Red),
        ColorNoParam :: Yellow => println!("{:?}",ColorNoParam::Yellow),
        ColorNoParam :: Blue => println!("{:?}",ColorNoParam::Blue),
    }
}

#[derive(Debug)]
enum ColorParam{
    Red(String), //带有String类型参数
    Yellow(String),
    Blue(String),
}

fn main(){
    //使用这种枚举值需要传入实参
    println!("{:?}",ColorParam::Blue(String::from("blue")));
}

// 创建空的动态数组
let mut v: Vec<i32> = Vec::new();
// 创建指定容量的动态数组
let mut v: Vec<i32> = Vec::with_capacity(10);
// 使用vec!宏在创建动态数组的同时进行初始化，并且根据初始值自动推断动态数组的元素类型
let mut v: Vec<i32> = vec![]; // 没有初始值，需要声明元素类型
let mut v = vec![1,2,3]; // 自动推断元素个数
let mut v = vec![0;10]; // 10个元素，元素的初始值都是0

// 使用push方法在动态数组尾部添加新元素
v.push(1);
// 使用数组名[索引] 获取元素
v[1] = 5;
// 使用pop方法删除并返回动态数组的最后一个元素，如果数组为空返回None
v.pop();
// remove方法删除并返回动态数组指定索引的元素，同时后面的所有元素向前移动一位
// 索引越界将导致程序错误
v.remove(1);

//使用索引访问
v[2];
// 使用get方法以索引作为参数访问
v.get(1);
// 遍历
for i in v {
    print!("{}",i);
}
// 可变引用
for i in &mut v {
    *i += 50;
    print!("{}",i);
}

// 创建空的VecDeque
let mut v : VecDeque<u32> = VecDeque::new();
// 创建指定容量的VecDeque
let mut v : VecDeque<u32> = VecDeque :: with_capacity(10);

// push_front 在队列头部添加新的元素
v.push_front(1);
// push_back 在尾部添加新元素
v.push_back(2);

// 使用索引修改元素
v[1] = 5;

// pop_front 删除并返回队列的头部元素
v.pop_back();
// pop_back 删除并返回尾部元素
v.pop_front();

// remove 删除并返回队列指定索引的元素，同时后面的所有元素向左移动一位
// 索引越界返回None
v.remove(1);

// 使用索引访问
v[0];
// 使用get方法以索引作为参数访问元素
v.get(0);

// 创建空的HashMap
let mut map: HashMap<&str,i32> = HashMap::new();
// 创建指定容量
let mut map: HashMap<&str,i32> = HashMap::with_capacity(10);

// insert 执行插入或者更新
// 键不存在，执行插入并返回None
// 键存在，执行更新，并返回旧值
let zhangsan = map.insert("zhangsan",16);

// 使用entry 和 or_insert 方法检查是否有对应值，没有对应值就插入，有对应值不执行操作
// entry方法以键为参数，返回值是一个枚举类型Entry
// Entry类型的or_insert 方法以值为参数，在键有对应值时不执行任何操作，没有对应值时，将键与值组成键值对插入
map.entry("zhangsan").or_insert(23);

// iter_mut 方法会返回由所有键值对的可变引用组成的迭代器
for( _, val ) in map.iter_mut() {
    *var += 2; // 所有的值都加2
}

// remove 删除并返回指定键值对的值，不存在返回None
let result = map.remove("wkk");

// 使用实例名[键] 访问指定键值对， 键不存在会导致程序错误
map["wkk"]

// 使用get 方法，以键作为参数访问指定的键值对，存在返回值，不存在返回None
map.get("wkk");

// 使用双引号创建字符串字面量
let s1 = "hello,wkk";

// 使用as_str方法将字符串对象转换为字符串字面量
let str = String::from("hello,wkk");
let s2 = str.as_str();

// 创建空的字符串对象
let mut s = String::new();

// 根据指定的字符串字面量创建字符串对象
let s = String::from("wkk");

// 使用to_string 方法将字符串字面值转换为字符串对象
let str = "wkk";
let s = str.to_string();

let mut s = String::from("wkk");
s.push('R');
s.push_str("111");

s.insert(5,',');
s.insert_str(7,"Rust ");

let s = "hello " + "wkk";

let s = format!("{}-{}-{}",s1,s2,s3);

let s1 = s.replace("aa","77");
let s2 = s.replace("aa","77",1);

s.pop();
s.remove(9);
s.truncate(9);
s.clear();

s.len();

// 按字节遍历
let bytes = s.bytes();
for b in bytes {
    print!("{} |",b);
}
// 按字符遍历
let chars = s.chars();
for c in chars{
    print!("{} |",c);
}

+ - * / % 

> < >= <= == != 

&& || !

& | ^ ! << >>