一起学Rust-变量及类型

//主函数
fn main() {
    //定义并初始化一个变量var1
    let var1 = 1;
    
    //打印格式化文本并在结尾输出换行
    println!("{}", var1);
}

➜  varandtype git:(master) ✗ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/varandtype`
1

fn main() {
    //默认为不可变变量
    let var1 = 1;
    println!("{}", var1);
    
    //对不可变变量重新赋值
    var1 = 2;
    println!("{}", var1);
}

error[E0384]: cannot assign twice to immutable variable `var1`
 --> src/main.rs:8:5
  |
4 |     let var1 = 1;
  |         ----
  |         |
  |         first assignment to `var1`
  |         help: make this binding mutable: `mut var1`
...
8 |     var1 = 2;
  |     ^^^^^^^^ cannot assign twice to immutable variable

error: aborting due to previous error

For more information about this error, try `rustc --explain E0384`.
error: Could not compile `varandtype`.

let var1;  //如果只有声明，而始终未赋值是不能编译的

let var1;  //声明
var1 = 2;  //初始化，这里不是修改，而是初始化变量。
//var1 = 3;  这是修改，是不允许的，因为var1是不可变变量。

//定义可变变量 mut var1
let mut var1 = 1;
println!("{}", var1);  //输出1
var1 = 2;
println!("{}", var1);  //输出2

//定义一个整型静态变量，静态变量定义时必须要同时初始化并指定类型
static VAR1:i32 = 0;
//定义一个可变静态变量
static mut VAR2:i32 = 0;

//在unsafe作用域中读写VAR2
unsafe {
    println!("{}", VAR2);  //输出0
    VAR2 = 2;
    println!("{}", VAR2);  //输出2
}
//println!("{}", VAR2); 这里是不被允许的
println!("{}", VAR1);  //输出0

//全局变量
static VAR1:i32 = 0;

fn main() {
    println!("{}", VAR1);
    test();
}

fn test() {
    println!("{}", VAR1);
}

const A:i32 = 0;

let mut var1 = 1;  //默认i32类型
//var1 = 'a';  可变变量：值可以变，类型不能变。

let ch:char = '天';

//定义三个元素的元组
let mut var1:(u8, char, i32) = (1,'1',3);
println!("{}", var1.0);  //通过“变量.索引”的形式访问指定元素。

let arr:[i32; 4] = [1, 2, 3, 0];

//创建一个指定类型的空vector
let vector:Vec<i32> = Vec::new();

//vector.push(1);   这句是无法执行的，因为vector不是可变变量。需要使用mut

let v2 = Vec::new();
v2.push(2);  //可以执行，而且从创建第一个标量值后，即可确定v2的类型是i32
//v2.push('a');  此句无法成功编译，类型不正确，

let v3 = vec![];    //通过vec宏创建空的向量
let v4 = vec![1,2,3];  //通过vec宏创建类型为i32的向量，拥有3个元素。

println!("{}", v4[v4.len() - 1]);  //访问v4的最后一个元素，输出3；

//属于字面量字符串，值是确定的，类型为 &str
let s:&str = "abc";

let mut s:&str = "abc";

//创建空字符串
let str:String = String::new();
//从abc字面量字符串创建String类型
let str1:String = String::from("abc");
//从abc字面量字符串创建String类型,与上一句作用相同。
let str2:String = "abc".to_string();

//以上字符串不可修改，均为只读，未加mut修饰符。

let string = "abc".to_string();

//获取string的索引1开始到结尾到片段的引用。
let str:&str = &string[1..];  

let arr = [1,2,3,4,5];
let arr_slice = &arr[2..4];  //取片段引用，取到[3,4]
let arr_slice2 = &arr[2..=4];  //取片段引用，取到[3,4,5]

//定义key为字符串引用，值为整数，
let mut ha<&str,i32> = HashMap::new();

//新增一个键值对
ha.insert("sd", 2);
println!(" {:?}", ha);