流程控制
Rust是一个基于表达式的语言，大多数代码都有一个返回值。除了一些声明语法。 条件与循环也是表达式，所以它们可以有返回值。
let cond = true;
let a = if cond {
32
}else {
23
};
if else
let n = 5;
if n > 0 {
println!("{} is positive",n);
}else if n < 0 {
println!("{} is negative",n);
}else {
println!("{} is zero",n);
}
// 作为表达式
// 返回值各个分支的值必须相同
let b = if n < 0 {
2.0
}else {
3.0
};
println!("{}",b);
loop
fn main() {
// 1 + 2 + 3 ... 100
let mut sum = 0;
let mut index = 1;
// 可以将loop的值赋给一个变量
let result = loop {
sum += index;
index += 1;
if index > 100 {
break sum * 2
}
};
println!("sum = {}, index = {}, result : {}",sum,index,result);
}
for range
Rust中的for…in…语法可以用来遍历一个迭代器，有多种方式可以创建一个迭代器。
- a..b 将创建一个包含a而不包含b，步长为1的迭代器。
- a..=b 将创建一个包含a且包含b，步长为1的迭代器。
for i in 0..5 {
println!("{}",i);
}
println!("-----");
for i in 0..=5{
println!("{}",i);
}
for range 遍历数组
fn main() {
let array = ["a","b","c","d"];
for i in array.iter() {
println!("{:?}",i)
}
// 使用 iter_mut() 可以修改元素，前提是数组定义的时候需要是 mut
// for i in array.iter_mut() {
// println!("{:?}",i)
// }
}
模式匹配
模式匹配 类似于其他语言中的switch
let opcode:u8 = 42;
match opcode {
42 => {
println!("123");
}
// default
_ => {
println!("321");
}
}
if let语法糖
可用来简化模式匹配的代码。只关心满足条件的操作。
let opcode:u8 = 42;
if let 42 = opcode {
println!("123");
}
也可以匹配枚举，包括枚举内的参数
enum Symbol {
Char(char),
Num
}
fn main() {
let f = Symbol::Char('A');
if let Symbol::Char(x) = f {
println!("{}",x)
}
}
// output
// A
while let语法糖
while let定义当满足条件时，while会一直执行下去
// 加上此语句将Symbol声明为可打印类型，println才能打印
#[derive(Debug)]
enum Symbol {
A,
B
}
fn main() {
let mut letter = Symbol::A;
while let Symbol::A = letter {
println!("{:?}",letter);
letter = Symbol::B
}
}
函数
#[derive(Debug)]
struct Point {
x: u64,
y: u64,
}
// 方法
impl Point {
fn new(x:u64,y:u64)->Point{
Point{x,y}
}
fn get_x(&self) -> u64{
self.x
}
fn set_x(&mut self,x:u64){
self.x = x
}
}
fn main() {
let mut p = Point::new(10,20);
println!("{:?}",p);
println!("{:?}",p.x);
println!("{:?}",p.get_x());
p.set_x(30);
println!("{:?}",p.get_x());
//println!("{}",fibonacci(10))
}
// 函数
fn fibonacci(n: u64) ->u64 {
if n < 2 {
n
}else {
fibonacci(n - 1) + fibonacci(n-2)
}
}
move语法
use std::thread;
fn main() {
let hm = "hello world";
// move : 将环境中的值移到闭包内部
// 使用场景-多线程：从主线程移动到子线程
thread::spawn(move || {
// hm是主线程中的值
println!("{}",hm);
}).join();
}
高阶函数
满足以下条件即是一个高阶函数
- 接受一个或多个函数作为输入
- 输出一个函数
fn main() {
let a = 5;
let b = 4;
println!("{}",calc(add,a,b));
println!("{}",calc(sub,a,b));
// 使用函数作为返回值
println!("{}",calc2("add")(a,b));
println!("{}",calc2("sub")(a,b));
}
fn add(a:u32,b:u32)->u32{
a+b
}
fn sub(a:u32,b:u32)->u32{
a-b
}
type Method = fn(u32,u32)->u32;
fn calc(method: Method,a:u32,b:u32)->u32{
method(a,b)
}
fn calc2(method: &str)->Method{
match method {
"add" => add,
"sub" => sub,
_ => unimplemented!()
}
}
示例
extern crate rand;
// 引入随机数生成函数
use rand::Rng;
use std::io;
use std::io::Read;
fn main(){
let secret_number = rand::thread_rng().gen_range(1..101);
loop {
// 获取用户输入
println!("input :");
let mut guess = String::new();
// 读取用户输入
io::stdin().read_line(&mut guess).unwrap();
let guess_number: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_err) => continue
};
println!("You guessed: {}",guess_number);
// 判断大小
if guess_number > secret_number {
println!("too big");
}else if guess_number < secret_number {
println!("too small");
}else {
println!("You are 666");
break;
}
}
}