数据类型

整数类型 Integer

整数类型没有小数部分

• 无符号整数类型以u 开头 (大于等于 0)
• 有符号整数类型以i 开头 (正数或负数或 0)

示例

fn main() {
    let n = 10; // i32
    let b = 128; // u8
}

浮点类型 Floating Point

有小数部分的类型

示例

fn main() {
    let x = 2.0; // f64:默认8字节

    let y: f32 = 3.0; // f32:4字节
}

布尔类型 Boolean

示例

fn main() {
    let t = true; // bool 1个字节
}

字符类型 Character

示例

fn main() {
    let a: char = '😂'; // char 4个字节
}

复合类型

复合类型可以将多个值放在一个类型里

元组 Tuple

Tuple 可以将多个类型的多个值放在一个类型里，也就是不同类型数据的集合 长度是固定的，一旦声明就无法改变。

创建元组

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);

    // 获取元组的元素值
    // 模式匹配解构
    let (x, y, z) = tup;

    println!("{} {} {}", x, y, z); // 500 6.4 1

    // 访问元组的元素
    println!("{} {} {}", tup.0, tup.1, tup.2); // 500 6.4 1
}

数组 Array

数组也可以将多个值放在一个类型里，也就是相同类型数据的集合 数组中每个元素的类型必须相同。 数组的长度也是固定的。

声明数组

fn main() {
    // 声明方式一
    let f = [10, 20, 30];

    // 声明方式二
    // 数组的类型:i32,长度:5
    let a: [i32; 5] = [1, 2, 3, 4, 5];

    // 声明方式三
    let b = [3; 5];
    // 相当于下面的声明
    let b = [3, 3, 3, 3, 3];

    // 访问数组的元素
    let a1 = a[0];
}

字符串

创建字符串的几种方式

let str1 = String::from("Hello");

let str2  = "Hello".to_string();

let str3 = "Hello".to_owned();

字符串切片

let str_slice : &str = "Hello"

结构体

struct User {
    id: String,
    name: String,
    gender: Gender,
}

// 初始化结构体
let user = User {
    id = "001",
    name = "tom",
    gender = Gender::MALE
}

// 给结构体实现方法
impl User {
    // 关联方法
    fn new()- > Self {
        Self {}
    }

    // 实例方法
    fn print(&self) {
        println!("{:#?}",self)
    }
}

let u1 = User::new(
)
// 调用实例方法
u1.print()

// 使用关联方法
User::print(&u1)

枚举

enum Gender {
    MALE,
    FEMALE,
}

Vector

fn main() {
    let mut list  = Vec::new();
    list.push(1);
    list.push(2);
    list.push(3);

    // for item in list {
    //     println!("item is {}", item);
    // }

    // 使用迭代器
    list.iter().for_each(|item| {
        println!("{}", item);
    });
}

Trait

fn main() {
    let player = Player::new("Tom");
    let game = Game::new(player);

    game.play(); // Tom is playing
}

// 定义一个特征
// 特征定义了类型可以实现的方法
trait Person {
    fn get_name(&self) -> String;
    fn say_hello(&self) {
        // 默认实现
        println!("Hello, {}!", self.get_name());
    }
}

// 定义结构体
struct Player {
    name: String,
}

impl Player {
    fn new(name: &str) -> Self {
        Self {
            name: String::from(name),
        }
    }
}

// 实现特征
impl Person for Player {
    fn get_name(&self) -> String {
        self.name.clone()
    }

    fn say_hello(&self) {
        println!("Hello, {}!", self.get_name());
    }
}

struct NewBorn {}

impl Person for NewBorn {
    fn get_name(&self) -> String {
        String::from("Unknown")
    }
}

// 泛型约束
struct Game<T: Person> {
    person: T,
}

impl<T: Person> Game<T> {
    fn new(person: T) -> Self {
        Self { person }
    }

    fn play(&self) {
        println!("{} is playing", self.person.get_name());
    }
}