Rust语言教程(2)从熟悉的部分开始

虽然有默认不变性还有所有权的问题让Rust一上来用起来有些不同&＃xff0c;但是其实大部分语法特点还是我们所熟悉的。
我们没必要上来就跟自己死磕&＃xff0c;可以先从我们熟悉的部分开始学习。

一般我们写代码&＃xff0c;使用的主要是数据类型、控制结构和函数。我们就从这三部分开始。

数据类型

与Go一样&＃xff0c;Rust的定义语句数据也是放在变量名后面的&＃xff0c;不过还要加上一个冒号。

布尔类型

布尔类型是bool&＃xff1a;

let b0 : bool &＃61; true;


因为Rust是有类型推断的功能&＃xff0c;所以很多时候可以不用指定类型。

let b1 &＃61; true;let b2 &＃61; !b1;let b3 &＃61; 1 > 0;println!("{} {} {}",b1,b2,b3);


如果使用CLion等IDE的话&＃xff0c;就可以直接看到IDE提供的灰色的类型推断的提示&＃xff0c;非常方便&＃xff1a;

字符类型 - 传统与现代的结合

Rust的字符类型支持的是Unicode类型&＃xff0c;占用4个字节。同时&＃xff0c;Rust也支持单字节ASCII值&＃xff0c;这时用b开头&＃xff0c;类型值就是8位无符号类型u8。

我们来看例子&＃xff1a;

let c1 :char &＃61; &＃39;C&＃39;;let c2:u8 &＃61; b&＃39;C&＃39;;let c3 &＃61; &＃39;中&＃39;;println!("{} {} {}",c1,c2,c3);


同样&＃xff0c;我们可以将字符组成字符串&＃xff0c;我们来看例子&＃xff1a;

let s1 &＃61; "Hello";let s2 &＃61; b"World";println!("{} {:?}",s1,s2);


输出结果为&＃xff1a;

Hello [87, 111, 114, 108, 100]


s1的真实类型是str类型&＃xff0c;而s2是u8的数组。

let s1 :&str &＃61; "Hello";let s2 :&[u8;5] &＃61; b"World";


整数类型: 后缀与下划线齐飞

按照长度&＃xff0c;Rust的整数类型支持8位&＃xff0c;16位&＃xff0c;32位&＃xff0c;64位&＃xff0c;128位。根据有符号和无符号&＃xff0c;分为有符号的i8,i16,i32,i64,i128和无符号的u8,u16,u32,u64,u128。
除此之外&＃xff0c;也有根平台相关的类型&＃xff0c;有符号为isize类型&＃xff0c;无符号为usize类型。

我们看下例子&＃xff1a;

let i1 : i8 &＃61; -8;let i2 : i16 &＃61; -16;let i3 : i32 &＃61; -32;let i4 : i64 &＃61; -64;let i5 : i128 &＃61; -128;let u1 : u8 &＃61; 8;let u2 : u16 &＃61; 16;let u3 : u32 &＃61; 32;let u4 : u64 &＃61; 64;let u5 : u128 &＃61; 128;let p1 : isize &＃61; -1;let p2 : usize &＃61; 1;


上面都是跟其它语言比较像&＃xff0c;下面我们来看看Rust特色的后缀。这在C&＃43;&＃43;中也有&＃xff0c;比如10l, 200L之类的。
在Rust中&＃xff0c;我们直接用类型名做为后缀&＃xff0c;我们看个例子&＃xff1a;

let i6 &＃61; -1i8;let i7 &＃61; -2i16;


这样放在一起可能不太容易区分&＃xff0c;没关系&＃xff0c;Rust允许我们在数字上任意的加下划线来提升可读性&＃xff0c;我们来看几个例子&＃xff1a;

let i08 &＃61; -3_i32;let i09 &＃61; -4__i64;let i10 &＃61; -5___i128;


下划线并非只是用于数字和类型区分&＃xff0c;也可以加在数字中间&＃xff0c;我们来看个例子&＃xff1a;

let u6 &＃61; 1_000_000_u128;println!("{}",u6);


默认的整数类型是i32&＃xff0c;如果Rust无法推断中整数的类型&＃xff0c;那么就默认为i32.

整数的进制

在Rust中&＃xff0c;避免了077这样对八进制的偏爱&＃xff0c;改为用0o来表示8进制整数。16进制仍然是0xFF前缀&＃xff0c;二进制用0b前缀。

我们看例子&＃xff1a;

let u07 &＃61; 0xFF_u32;let u08 &＃61; 0o7777_u32;let u09 &＃61; 0b01_10_00_u8;println!("{} {} {}",u07,u08,u09);


输出结果为&＃xff1a;

255 4095 24


整数的溢出

在C语言中&＃xff0c;整数的溢出也是一个常出现的问题。
对此&＃xff0c;Rust在debug模式下&＃xff0c;在编译时会检查整数的溢出的问题&＃xff1a;

let i_10 : i8 &＃61; 0x7f;let i_11 : i8 &＃61; i_10 * 10i8;println!("{}",i_11);


在编译时&＃xff0c;Rust就会报错&＃xff1a;

84 | let i_11 : i8 &＃61; i_10 * 10i8;| ^^^^^^^^^^^ attempt to compute &＃96;i8::MAX * 10_i8&＃96;, which would overflow


懂程序分析的同学可能会想&＃xff0c;在编译时检查不出来怎么办&＃xff1f;好办&＃xff0c;我们在运行时进行检查。
我们来个例子&＃xff1a;

let mut i_20 : i8 &＃61; 0x20;for i in 1..20{i_20 &＃61; 0x20_i8 * i_20;}println!("{}",i_20);


在运行时仍然发现了溢出&＃xff1a;

thread &＃39;main&＃39; panicked at &＃39;attempt to multiply with overflow&＃39;, src/main.rs:91:16
stack backtrace:0: rust_begin_unwindat /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/panicking.rs:4831: core::panicking::panic_fmtat /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/panicking.rs:852: core::panicking::panicat /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/panicking.rs:503: tools::testat ./src/main.rs:914: tools::mainat ./src/main.rs:345: core::ops::function::FnOnce::call_onceat /Users/lusinga/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs:227
note: Some details are omitted, run with &＃96;RUST_BACKTRACE&＃61;full&＃96; for a verbose backtrace.


类型转换

Rust语言是强类型的语言&＃xff0c;不像C一样有默认的类型转换。如果进行跨类型计算需要进行类型转换。
类型转换使用“as 类型”的方法来写&＃xff0c;我们来看个例子&＃xff1a;

let i_100 : i32 &＃61; (16i8 &＃43; 1) as i32;


i8计算之后还是i8&＃xff0c;不能直接赋给i32类型&＃xff0c;需要通过as i32来转换类型。

如果计算的类型不同&＃xff0c;编译不报错&＃xff0c;在运行的时候也会被检查出来。
我们看个例子&＃xff1a;

let i_101 &＃61; 16i8 &＃43; 32i32;


会报下面的错&＃xff1a;

error[E0308]: mismatched types--> src/main.rs:99:24|
99 | let i_101 &＃61; 16i8 &＃43; 32i32;| ^^^^^ expected &＃96;i8&＃96;, found &＃96;i32&＃96;


后面还有一个有趣的报错&＃xff0c;让trait露了一个爪印&＃xff1a;

error[E0277]: cannot add &＃96;i32&＃96; to &＃96;i8&＃96;--> src/main.rs:99:22|
99 | let i_101 &＃61; 16i8 &＃43; 32i32;| ^ no implementation for &＃96;i8 &＃43; i32&＃96;|&＃61; help: the trait &＃96;Add&＃96; is not implemented for &＃96;i8&＃96;


浮点数

浮点数跟C语言差不多&＃xff0c;分为32位浮点数和64位浮点数&＃xff0c;就这两种&＃xff0c;分别是f32和f64。默认为f64。
我们来看两个例子&＃xff1a;

let f_01 &＃61; 2.1;let f_02 &＃61; 2e8;


f_01和f_02都是f64类型。

需要注意的是&＃xff0c;对于除0的处理&＃xff0c;会引入两个新的值&＃xff1a;

• 对于非0除以0&＃xff0c;得到的将是无穷大inf
• 而对于0除以0&＃xff0c;将得到NaN&＃xff0c;意思是并不是一个数

我们来看例子&＃xff1a;

let f_03 &＃61; 0.0 / 0.0;let f_04 &＃61; 1.0 / 0.0;println!("{} {}",f_03,f_04);


输出结果为&＃xff1a;

NaN inf


NaN对应的本尊是std::f64::NAN&＃xff0c;而inf是std::f64::INFINITY&＃xff0c;我们将其排列在一起&＃xff1a;

let f_03 &＃61; 0.0 / 0.0;let f_04 &＃61; 1.0 / 0.0;let f_05 &＃61; std::f64::INFINITY;let f_06 &＃61; std::f64::NAN;println!("{} {} {} {}",f_03,f_04,f_05,f_06);


输出结果为&＃xff1a;

NaN inf inf NaN


32位和64位的无穷大都是无穷大&＃xff0c;它们是相等的&＃xff1a;

let f_10 &＃61; std::f32::INFINITY;let f_11 &＃61; std::f64::INFINITY;println!("{}",f_11&＃61;&＃61;f_10 as f64);


输出结果为&＃xff1a;

true


但是要注意的是&＃xff0c;两个NAN是不相等的&＃xff1a;

let f_12 &＃61; std::f64::NAN;println!("{}",f_12&＃61;&＃61;f_12);


结果为false.

流程控制

分支语句

Rust支持if-else表达式&＃xff0c;用来处理分支。
if后面不必加括号&＃xff0c;有点像Go&＃xff0c;我们看个例子&＃xff1a;

if n >&＃61; 100 {println!("Grade A");}else if n>&＃61; 60 {println!("Pass");}else{println!("Fail");}


可以写成更像表达式一点的方式&＃xff1a;

let grade &＃61; if n &＃61;&＃61; 100{"A"}else if n>&＃61;60{"Pass"}else{"Fail"};


如果用作表达式的话&＃xff0c;if和else两个分支返回的结果需要转换成同一类型&＃xff0c;毕竟Rust是这么强类型的语言。

循环语句

Rust的循环分为三种&＃xff1a;死循环loop&＃xff0c;while循环和for循环。

loop最直接干脆&＃xff0c;不需要while(true)或者for(;;)这种写法&＃xff0c;直接loop。如果需要退出循环就用break&＃xff0c;继续下一轮循环就用continue。

我们来个简单例子&＃xff1a;

let mut num &＃61; 0;let mut sum &＃61; 0;loop{if num > 10 {break;}else{sum &＃43;&＃61; num;num &＃43;&＃61; 1;}}println!("sum&＃61;{}",sum);


我们再将其翻译成while循环&＃xff1a;

num &＃61; 0;sum &＃61; 0;while num <&＃61; 10 {sum &＃43;&＃61; num;num &＃43;&＃61; 1;}println!("sum&＃61;{}", sum);


与if一样&＃xff0c;while后面也不强制要求括号。

最后是for循环&＃xff0c;它主要用于迭代器的遍历&＃xff1a;

sum &＃61; 0;for i in 0..11 {sum &＃43;&＃61; i;}println!("sum&＃61;{}", sum);


函数

最后说下函数&＃xff0c;Rust的函数使用fn关键字来定义。返回值的类型用->分隔而不是":"。
另外&＃xff0c;Rust中不一定非要用return语句来返回值&＃xff0c;表达式的值即可&＃xff0c;我们看个例子&＃xff1a;

fn fib2(n: i32) -> i64 {if n <&＃61; 2 {1i64} else {fib2(n - 1) &＃43; fib2(n - 2)}
}


按传统写法也是可以的&＃xff1a;

fn fib2(n: i32) -> i64 {if n <&＃61; 2 {return 1i64} else {return fib2(n - 1) &＃43; fib2(n - 2)}
}


或者将return提到if表达式外面&＃xff1a;

fn fib2(n: i32) -> i64 {return if n <&＃61; 2 {1i64} else {fib2(n - 1) &＃43; fib2(n - 2)}
}


小结

在使用基本类型的情况下&＃xff0c;Rust跟C语言和Go语言的基础部分其实还是很类似的&＃xff0c;熟悉Javascript等语言的同学也不会觉得陌生。我们可以把原有的知识迁移过来&＃xff0c;基本类型变量如果需要修改值的话就加个mut。