上一节给出了以下示例:
fn main() {
println!("Hello World!");
}
从上述代码中,可以了解到关于 Rust 的一些信息:
- 程序入口为
main
函数。 - 每条语句以分号结尾。
println!
是输出语句。fn
用来声明函数- ....
本节中,我们简单介绍一些 Rust 的通用编程概念。假定你有一些编程基础,那么 15 分钟了解到这些不成问题。
Rust 中注释有三种:
- 单行注释
- 多行注释
- 注释文档
/// 这是注释文档
//! 这也是注释文档
fn main() {
// 这是单行注释
/* 这是多行注释的单行形式 */
/**
* 这是多行注释
*/
println!("Hello, World");
}
其实,Rust 作为一门现代语言,注释所能提供的功能非常丰富,甚至在注释文档中,还支持 markdown 标记,也支持对文档中的示例代码进行测试,也可以使用 rustdoc 工具生成 HTML 文档。
注该小节的所有修改均均处于
main
函数中。
Rust 中遵从 let-binding 规范,所以,创建一个变量的方式是使用 let
.
// 创建一个变量
let a = 1;
我们知道,Rust 是静态类型语言,因此变量 a
通过类型推断而获取了类型。
当然,也可以使用 :
来显示地指定类型:
// 创建一个类型为 i64 的变量
let b:i64 = 2;
但是,这里有一个问题需要注意:Rust 中,单纯使用 let
声明的变量是不可变的,即:
let c = 3;
c = 4;
// error: cannot assign twice to immutable variable
如果想要创建一个可变类型的变量,则需要使用 mut
关键字:
let mut c = 3;
c = 4;
println!("c = {}", c);
// output: c = 4
当然,Rust 也提供了 const
来定义常量:
const d = 4;
而关于 const
与 let
的不同之处,这里不再提及。
还有,Rust 提供了一种隐藏机制,例如:
let e = 5;
let e = 6;
上述语法在 Rust 中是被允许的,let e = 6;
意味着:声明一个新的变量 e
, 其值为 6
, 而之前值为 5
的 e
, 已经被隐藏了。
在变量一节中,我们已经提及 Rust 是静态类型语言。
- 静态类型:编译期间,即需要知道变量的具体类型。
在 Rust 中,含有:
- 四种标量类型:1. 整型;2. 浮点型;3. 布尔型;4. 字符型;
- 两种复合类型:1. 元组;2. 数组。
let _int8:i8 = 1; // 8 位有符号整数
let _unsigned8:u8 = 2; // 8 位无符号整数
let _int16:i16 = 3; // 16 位有符号整数
let _unsigned16:u16 = 4; // 16 位无符号整数
let _int32:i32 = 5; // 32 位有符号整数,默认
let _unsigned32:u32 = 6; // 32 位无符号整数
let _int64:i64 = 7; // 64 位有符号整数
let _unsigned64:u64 = 8; // 64 位无符号整数
let _int128:i128 = 9; // 128 位有符号整数
let _unsigned128:u128 = 10; // 128 位无符号整数
let _iint: isize = 11; // 有符号整数,长度取决于运行平台
let _uint: usize = 12; // 无符号整数,长度取决于运行平台
let _float32:f32 = 13.0; // 32 位浮点数
let _float64:f64 = 14.1; // 64 位浮点数,默认
let _bool:bool = true; // 布尔类型
let _char:char = 'a'; // 字符类型,Rust 中使用 UTF-8 编码,而不是 ASCII
let _tup: (i32, f64, bool) = (1,2.0,false); // 元组
let _nums:[u8;5] = [0,1,2,3,4]; // 数组
在介绍这一部分之前,首先介绍表达式与语句的不同。
- 表达式:执行并产生一个值作为结果。例如,
5+6
是一个表达式,其结果为11
. - 语句:执行但是没有返回值。例如,
let x = (let y = 1);
是错误的写法,let y = 1
是一个语句没有返回值。
示例:
fn main() {
let y = 2;
let x = { // 这是 一条语句,最终的值为表达式 y 的结果
let y = 1; // 块级作用域
y // 一个表达式
};
println!("{}", x); // 1
}
Rust 中 if
表达式如下:
fn main() {
let num = 1;
if num > 1 {
println!("num is less 1");
} else {
println!("num is ge 1");
}
}
Rust 提供了三种循环:
loop
: 用法:loop {}
一直循环,直到遇到显式的退出。while
:
fn main() {
let mut num = 0;
while num < 10 {
num = num + 1;
}
}
- for 循环:
fn main() {
let arr = [1,2,3,4];
for it in arr.iter() {
println("{}",it);
}
}
从之前的内容可以了解到:main
函数是程序的入口,关键字fn
可以声明函数。
下面,来介绍另外一个函数:
fn main() {
println!("{}", fib(10)); // 55
}
fn fib(n:i32) -> i32 {
if n <= 0 {
return 0;
}
if n == 1 {
return 1;
}
return fib(n-1) + fib(n-2);
}
以上是 Rust 函数中最基本的用法,括号内是传入的参数,->
后是返回类型,大括号内是函数体。
当然,Rust 函数还能涉及到其他许多语法:
- 函数嵌套:Rust 中允许函数嵌套。
fn main() {
fn get_five() -> i32 {
5 // 与表达式
}
println!("{}", get_five()); // 5
}
- 宏与函数不同,例如
println!()
是一个宏,在 Rust 中,所有的宏都以!
作为结尾。
以上,就是一些通用编程概念在 Rust 中的展示。
接下来的章节,我们会用更多的示例来展示 Rust 的特性,并期待用 Rust 书写更多的项目。