【Rust】类型，函数，关联函数，控制，占位符

【Rust】类型，函数，控制

整类型

长度     有符号   无符号
8-bit    i8      u8
16-bit   i16     u16
32-bit   i32     u32
64-bit   i64     u64
128-bit  i128    u128
arch     isize   usize

let vi8 : i8 = 1;
let vu8 : u8 = 1;
let vi16 : i16 = 1;
let vu16 : u16 = 1;
let vi32 : i32 = 1;
let vu32 : u32 = 1;
let vi64 : i64 = 1;
let vu64 : u64 = 1;
let vi128 : i128 = 1;
let vu128 : u128 = 1;
let vi : isize = 1;
let vu : usize = 1;

 

浮点类型

长度      符号
32-bit    f32
64-bit    f64

let a : f32 = -1.1;
let b : f32 = 1.1;
let c : f64 = -2.2;
let d : f64 = 2.2;

 

布尔类型

布尔两个字节 true false

let flag = true;

 

字符类型

字符四个字节 unicode

let a = 'a';

 

元组类型

元组是一个将多个其他类型的值组合进一个复合类型的主要方式。元组长度固定：一旦声明，其长度不会增大或缩小。
我们使用包含在圆括号中的逗号分隔的值列表来创建一个元组。元组中的每一个位置都有一个类型，而且这些不同值的类型也不必是相同的

let tup: (i32, f64, u8) = (500, 6.4, 1);
let (a,b,c) = tup;// 解构值 a=500,b=6.4,c=1
let x = tup.0;// 索引值 x=500
let y = tup.1;
let x = tup.2;

 

数组类型

长度是固定的，分配在栈上

let a = [1,2,3,4,5];// 没有指定类型和长度，由初始值决定
let b: [u32;5] = [6,7,8,9,0];// 指定类型和长度
let c = ['c';3];// 设置相同的值，相当于['c','c','c']
let d = [3;2];// 设置相同的值，相当于[3,3]
let e = b[0];//获取数组值

 

函数

函数签名中必须显示的声明每个参数的类型。

语句statement：执行操作但不返回值的指令，let x = 1;

表达式expression：进行计算产生一个结果的指令，1 + 2。表达式的末尾加上分号;就变成了语句而不会返回任何值

// 没有返回值
fn show(v: u32) {
    println!("{}",v);
}
// retur 返回 u32
fn sum1(a: u32, b: u32) -> u32 {
    return a + b;
}
// 最末尾表达式返回，不能加分号，因为加了分号会使表达式变为语句而报错
fn sum2(a: u32, b: u32) -> u32 {
    a + b
}

关联函数 ( associated function ) ::

let mut guess = String::new();

:: 语法表明 new 是 String 类型的一个关联函数。关联函数（associated function）是实现一种特定类型的函数

注释

//

占位符

{}

是预留在特定位置的占位符

let x = 5;
let y = 10;
println!("x = {} and y = {}", x, y);

控制

if

let num: u32 = 10;
// 没有括号
if 5 > num && num > 0 {
} else if 10 > num && num > 5 {
} else if num % 4 == 0 {
} else {
}

loop

let mut num: u32 = 0;
// 使用break终止循环，使用continue继续循环
loop {
    num += 1;
    if num % 2 == 0 {
        continue;
    }
    if num > 10 {
        break;
    }
    println!("{}",num);
}
// 使用break终止循环并返回值
let result = loop {
    if num > 10 {
        break 999; // 返回值
    }
};// 分号不能少，这是语句
println!("{}",result);

while

let mut sum: u32 = 0;
let mut index: u32 = 1;
while index <= 100 {
    sum += index;
    index += 1;
}
println!("{}",sum);

for

let a = [10,20,30,40,50];
for item in a.iter() {
    println!("{}",item);
}
for item in 0..4 {
    println!("{}",item);// 结果0,1,2,3
}
for item in (0..4).rev() {
    println!("{}",item);// 结果3,2,1,0
}