Rust学习之旅——基础语法

变量

变量使用let来赋值，且大多数情况下可以自动推断变量类型，如果不行则需要手动添加变量声明。（变量命名遵循蛇形命名法）

fn main() {
    // rust 推断出x的类型
    let x = 13;
    println!("{}", x);

    // rust也可以显式声明类型
    let x: f64 = 3.14159;
    println!("{}", x);

    // rust 也支持先声明后初始化，但很少这样做
    let x;
    x = 0;
    println!("{}", x);
}

修改变量

Rust中变量分为可变的和不可变的，变量值用mut关键字表示

• 可变的 - 编译器允许对变量进行读取和写入
• 不可变的 - 编译器只允许对变量进行读取

fn main() {
	let mut x = 42;
	println!("{}", x);
	x = 13;
	println!("{}", x);
}

基本类型

Rust有多种常见类型：

• 布尔型 - bool 表示 true 或者 false
• 无符号整型 - u8 u32 u64 u128 表示正整数
• 有符号整型 - i8 i32 i64 i128 表示正负整数
• 指针大小的整数 - usize isize 表示内存中内容的索引和大小
• 浮点数 - f32 f64
• 元组（tuple） - （value, value, …) 用于在栈上传递固定序列（不能变）的值
• 数组 - 在编译时已知的具有固定长度的相同元素的集合
• 切片（slice） - 在运行时已知长度的相同元素的集合
• 字符串（str or string slice） - 在运行时已知长度的文本

可以通过将类型附加到数字的末尾来明确指定数字类型（如 13u32 和 2u8）
Rust是一种系统编程语言，更为关心内存问题

fn main() {
	let x = 12;		// 默认情况下是 i32
	let a = 12u8;
	let b = 4.3;	// 默认情况下是 f64
	let c = 4.3f32;
	let bv = true;
	let t = (13, false);
	let sentence = "hello world";
	println!(
		"{} {} {} {} {} {} {}",
		x, a, b, c, bv, t.0, t.1, sentence
	);
}

基本类型转换

当涉及到数字类型时，Rust要求明确，不应当出现把 “u8” 用在 “u32” 上。
不过Rust给出了 as 关键字，使得数字类型转换很容易

fn main() {
	let a = 13u8;
	let b = 7u32;
	let c = a as u32 + b;
	println!("{}", c);			// 20

	let t = true;
	println!("{}", t as u8);	// 1
}

常量

常量允许我们高效地指定一个在代码中会被多次使用的公共值。不同于像变量一样在使用的时候会被复制，常量会在编译期间直接用它们的值来替换变量的文本标识符。

不同于变量，常量必须始终具有显式的类型。常量名总是遵循 全大写蛇形命名法**（SCREAMING_SNAKE_CASE）**。

const PI: f32 = 3.1415926

fn main() {
	println!(
		"To make an apple {} from scratch, you must first create a universe.",
		PI
	);
}

数组

数组是所有相同类型数据元素的固定长度集合。
一个数组的数据类型是 [T;N]，其中 T 是元素的类型，N 是编译时已知的固定长度。

可以使用 [x] 运算符提取单个元素，其中 x 是所需元素的 usize 索引（从 0 开始）。

fn main() {
	let nums: [i32; 3] = [1, 2, 3];
	println!("{:?}", nums);
	println!("{}", nums[1]);
}

函数

函数可以有 0 个或者多个参数。

fn add(x: i32, y: i32) -> i32 {
	return x + y;
}

fn main() {
	println!("{}", add(42, 133));
}

在这个例子中，add 接受类型为 i32（32 位长度的整数）的两个参数。

函数名总是遵循 蛇形命名法 (snake_case)。

多个返回值

函数可以通过元组来返回多个值。

元组元素可以通过他们的索引来获取。

Rust 允许我们将后续会看到的各种形式的解构，也允许我们以符合逻辑的方式提取数据结构的子片段。

fn swap(x: i32, y: i32) -> (i32, i32) {
	return (y, x);
}

fn main() {
	// 返回一个元组
	let result = swap(123, 312);
	println!("{} {}", result.0, result.1);

	// 将元组解构成两个变量
	let (a, b) = swap(result.0, result.1);
	println!("{} {}", a, b);
}

返回空值

如果没有为函数指定返回类型，它将返回一个空的元组，也称为单元。

一个空的元组用 () 表示。

直接使用 () 的情况相当不常见。但它经常会出现（比如作为函数返回值）。

fn make_nothing() -> () {
	return  ();
}

// 返回类型隐含为 ()
fn make_nothing2() {
	// 如果没有指定返回值，默认返回 ()
}

fn main() {
	let a = make_nothing();
	let b = make_nothing2();
	
	// 打印a和b的debug字符串
	println!("The value of a: {:?}", a);
	println!("The value of b: {:?}", b);
}