Rust基础入门 面向对象 IO流 多线程 增删改查

为什么学习 Rust

Rust 是一种现代的、安全的、高效的系统编程语言，它因其出色的特性和功能而受到越来越多开发者的关注。

Rust 之所以备受青睐，主要在于其出色的安全性和效率。Rust 静态类型检查和所有权系统能在编译时检查代码，避免了许多常见的编程错误，如空指针引用和缓冲区溢出等。这使得 Rust 成为编写安全、可靠和高质量软件的理想选择。同时，Rust 能够提供与 C 和 C++类似的性能，且拥有更好的内存安全和线程安全。这使得 Rust 成为编写高性能系统和网络应用程序的良好选择。

除此之外，Rust 还是一种非常适合并发编程的编程语言。由于其所有权系统，Rust 能够保证线程安全，这使得并发编程变得更加容易。同时，Rust 还提供了许多并发编程的原语，如通道和锁等，使得开发者能够更加轻松地编写高效的并发代码。这对于那些需要处理大规模数据的应用程序尤为重要。

最后，Rust 还适用于 Web 开发，拥有许多适用于 Web 开发的框架和库，如 Rocket、Actix 等，这使得开发者能够更加轻松地构建高性能、安全和可靠的 Web 应用程序。同时，由于 Rust 的高性能和内存安全，它也适用于开发分布式系统、物联网等领域。

总之，Rust 的出色特性和功能使其成为未来编程语言的重要选择。作为开发者，学习 Rust 是非常有必要的。同时，Rust 的社区正在迅速发展，越来越多的开发者正在关注和使用 Rust，这也为 Rust 的未来发展提供了无限可能。

基础数据类型

• 整数类型：包括有符号整数 i8、i16、i32、i64、i128 和无符号整数 u8、u16、u32、u64、u128，以及 isize 和 usize 类型，它们的大小分别为 8、16、32、64、128 位。
• 浮点数类型：包括单精度浮点数 f32 和双精度浮点数 f64。
• 字符类型：使用单引号 '' 表示，大小为 4 个字节，支持 Unicode 字符集。
• 字符串类型：使用双引号 "" 表示，是一个动态可变的 UTF-8 字符串。
• 布尔类型：只有两个取值：true 和 false。
• 数组类型：固定长度的数组，元素类型相同。
• 元组类型：长度固定的有序集合，可以包含不同类型的元素。
• 切片类型：指向某个数组或向量的一段连续的元素序列。
• 向量类型：动态可变的数组，元素类型相同。
• 指针类型：包括原始指针 *const T 和 *mut T，以及引用 &T 和可变引用 &mut T。

命名规范

• 变量名：snake_case
• 函数名：snake_case
• 模块名：snake_case
• 结构体名：PascalCase
• 枚举名：PascalCase
• trait 名：PascalCase
• 文件名：snake_case.rs

面向对象

封装

foo.ts

pub struct Bar {
    
    
    field1: i32,
    field2: f64,
}

impl Bar {
    
    
    pub fn new() -> Bar {
    
    
        Bar {
    
    
            field1: 0,
            field2: 0.0,
        }
    }

    pub fn get_field1(&self) -> &i32 {
    
    
        &self.field1
    }

    pub fn get_field2(&self) -> &f64 {
    
    
        &self.field2
    }
}

mian.ts

mod foo;

use foo::{
    
    Bar};

fn main() {
    
    
    let bar = Bar::new();
    let field1 = bar.get_field1();
    let field2 = bar.get_field2();
    print!("{}",field1);
    print!("{}",field2);
}

继承和多态

// 定义一个 trait
trait Animal {
    
    
    fn make_sound(&self);
}

// 实现 Animal trait 的 Dog 类型
struct Dog {
    
    
    name: String,
}

impl Animal for Dog {
    
    
    fn make_sound(&self) {
    
    
        println!("{} says woof!", self.name);
    }
}

// 实现 Animal trait 的 Cat 类型
struct Cat {
    
    
    name: String,
}

impl Animal for Cat {
    
    
    fn make_sound(&self) {
    
    
        println!("{} says meow!", self.name);
    }
}

// 接受一个实现 Animal trait 的对象作为参数
fn make_animal_sound(animal: &dyn Animal) {
    
    
    animal.make_sound();
}

fn main() {
    
    
    let dog = Dog {
    
     name: String::from("Fido") };
    let cat = Cat {
    
     name: String::from("Whiskers") };

    make_animal_sound(&dog);
    make_animal_sound(&cat);
}

IO 流

获取当前文件夹内文件内容

fn main() {
    
    
    let path_buf = std::env::current_dir().unwrap();
    let current_path = path_buf.join("test.txt");
    let result = fs::read_to_string(current_path).unwrap();
    println!("With text:\n{}", result);
}

获取文件夹内的所有文件和文件夹

fn main() {
    
    
    let path_buf = std::env::current_dir().unwrap();
    let current_path = path_buf.join("target");
    let dirs = fs::read_dir(current_path).unwrap();
    for dir in dirs {
    
    
        let entry = dir.unwrap();
        let file_path = entry.path();
        println!("File name: {}", file_path.display());
    }
}

多线程

将集合内的数字全部+1

use std::sync::{
    
    Arc, Mutex};
use std::thread;

fn main() {
    
    
    // 创建一个新的线程安全共享引用计数的智能指针的函数
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));


    let handles: Vec<_> = (0..3)
        .map(|i| {
    
    
            let data = data.clone();
            // move关键词将闭包的所有权转移给新线程，保证了闭包内部使用的变量不会在创建新线程后被释放。
            thread::spawn(move || {
    
    
                let mut data = data.lock().unwrap();
                data[i] += 1;
            })
        })
        .collect();

    // 等待线程执行结束
    for handle in handles {
    
    
        handle.join().unwrap();
    }

    println!("{:?}", data);
}

操作数据库

对 MySQL 数据库数据进行增删改查

1. 引入依赖

[dependencies]
mysql = "*"

2. 实现代码

use mysql::{
    
    from_row, params, Pool, Value};
use mysql::prelude::Queryable;

#[derive(Debug, PartialEq, Eq)]
struct User {
    
    
    name: String,
    age: i32,
}

fn main() {
    
    
// 连接 MySQL 数据库
    let url = "mysql://root:123456@localhost:3306/demo";
    let pool = Pool::new(url).unwrap();
    let mut conn = pool.get_conn().unwrap();
    // 插入数据
    conn.exec_drop(
        "INSERT INTO demo (name, age) VALUES (?, ?)",
        (Value::from("Alice"), Value::from(18)),
    ).unwrap();

    // 查询数据
    let stmt = conn
        .prep("SELECT name, age FROM demo WHERE age > :age")
        .unwrap();
    let rows = conn.exec_iter(&stmt, params! {
    
     "age" => 20 }).unwrap();
    for row in rows {
    
    
        let (name, age): (String, i32) = from_row(row.unwrap());
        println!("{} is {} years old", name, age);
    }

    // 更新数据
    conn.exec_drop(
        "UPDATE demo SET age = ? WHERE name = ?",
        (Value::from(20), Value::from("Alice")),
    ).unwrap();

    // 删除数据
    conn.exec_drop("DELETE FROM demo WHERE age = ?", (Value::from(20), )).unwrap();
}