Rust从0️⃣入门(2) 基础语法2

发表于

基础语法2

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

  • tuple
    • 如果写成这样let aa = (1i32,true);
    • 代表第一个是i32类型，第二个是bool类型
    • 来看下面代码
1
2
3
4
5
6
7
8
9
rust复制代码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被赋值是使用了数字索引
    枚举
  • 一般读取枚举，会使用到模式匹配
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
rust复制代码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);
}

基本的算术表达式

1
2
3
4
5
6
7
rust复制代码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不加括号，编译器就会报错了
1
2
3
4
5
6
7
8
9
rust复制代码fn calculate(a: bool,b: bool,c: bool) -> bool {
    (a == b) == c
}

fn main() {

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

if-else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
rust复制代码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);
}

函数

1
2
3
4
5
6
7
8
rust复制代码fn add(t : (i32,i32)) -> i32 {
    t.0 + t.1
}

fn main() {
    //输出 3
    println!("{}",add((1,2)))
}
  • 上面函数的变种
1
2
3
4
5
6
7
8
rust复制代码fn add((x,y) : (i32,i32)) -> i32 {
    x + y
}

fn main() {
    //输出 3
    println!("{}",add((1,2)))
}
  • 当类型转换遇上函数
    • add1是传入一个参数
    • 而add2是传入一个tuple，两个i32类型的变量
    • 下面代码，相当于func进行了类型转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
rust复制代码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)))
}

条件判断配合函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
rust复制代码fn check(x : bool) -> i32 {
    let p = if x {
        panic!("Error!");
    } else {
        7
    };
    return p;
}

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

递归之斐波那契

1
2
3
4
5
6
7
8
9
10
11
12
13
rust复制代码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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
rust复制代码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来访问内部成员

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%