小知识，大挑战！本文正在参与“程序员必备小知识”创作活动。

基础语法2

由于rust语法与大部分语言语法差别较大，所以慢一点学习语法元祖

tuple
- 如果写成这样let aa = (1i32,true);
- 代表第一个是i32类型，第二个是bool类型
- 来看下面代码

fn main() {
    let p = (1i32, 2i32);
    let (a , b) = p;
    let x = p.0;
    let y = p.1;

    // 输出 1 2 1 2
    println!("{} {} {} {}",a,b,x,y);
}

其中a,b被赋值是使用了模式匹配
- 而x,y被赋值是使用了数字索引 枚举
一般读取枚举，会使用到模式匹配

use std::num::NonZeroU8;

enum Number {
    Int(i32),
    Float(f32)
}

fn input_num(num : &Number) {
    match num {
        &Number::Int(v) => println!("Integer {}",v),
        &Number::Float(v) => println!("Float {}",v),
    }
}

fn main() {

    let n : Number = Number::Int(100);
    // 输出 Integer 100
    input_num(&n);
}

基本的算术表达式

fn main() {

    let x = 100;
    let y = 10;
    // 110 90 1000 10 0
    println!("{} {} {} {} {}", x + y, x - y, x * y, x / y, x % y);
}

代码小规定

如果出现连续等于的判断，需要适当的根据语义去增加括号
- 如果下面的代码，a==b==c不加括号，编译器就会报错了

fn calculate(a: bool,b: bool,c: bool) -> bool {
    (a == b) == c
}

fn main() {

    // true
    println!("{}",calculate(false,true,false));
}

if-else

fn func(i: i32) {
    if i > 10 && i < 20 {
        print!("i > 10");
    }else if i > 20 && i < 30 {
        print!("i > 20")
    }else {
        print!("i > 30")
    }
}

fn main() {
    // i > 30
    func(40);
}

函数

fn add(t : (i32,i32)) -> i32 {
    t.0 + t.1
}

fn main() {
    //输出 3
    println!("{}",add((1,2)))
}

上面函数的变种

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

fn main() {
    //输出 3
    println!("{}",add((1,2)))
}

当类型转换遇上函数
- add1是传入一个参数
- 而add2是传入一个tuple，两个i32类型的变量
- 下面代码，相当于func进行了类型转换

fn add1(t : (i32,i32)) -> i32 {
    t.0 + t.1
}

fn add2((x,y) : (i32,i32)) -> i32 {
    x + y
}

fn add3(x: i32,y: i32) -> i32 {
    x + y
}

fn main() {
    let mut func : fn((i32,i32)) -> i32 = add1;
    func = add2;
    //输出 7
    println!("{}",func((2,5)))
}

条件判断配合函数

fn check(x : bool) -> i32 {
    let p = if x {
        panic!("Error!");
    } else {
        7
    };
    return p;
}

fn main() {
    let func = check(false);
    //输出 7
    println!("{}",func)
}

递归之斐波那契

fn fib(i : u32) -> u64 {
    if i == 1 || i == 2 {
        return 1
    } else {
     return fib(i - 1) + fib(i - 2);
    }
}

fn main() {
    let c = fib(10);
    //输出 55
    println!("{}",c)
}

trait

trait Shape {
    fn area(self: &Self) -> f64;
}

struct Circle {
    r: f64,
}

impl Shape for Circle {
    fn area(self: &Self) -> f64 {
        std::f64::consts::PI * self.r * self.r
    }
}


fn main() {
    let c = Circle {r : 3f64};
    //输出 圆的面积为 28.274333882308138
    println!("圆的面积为 {}",c.area())
}

上面代码可以看出
- 如果有一个Circle类型的实例c，我们就可以调用内部的c.area()
- 可以通过self.r来访问内部成员

Rust从0️⃣入门(2)

基础语法2