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 的未来发展提供了无限可能。

基础数据类型

  • 整数类型:包括有符号整数 i8i16i32i64i128 和无符号整数 u8u16u32u64u128,以及 isizeusize 类型,它们的大小分别为 8、16、32、64、128 位。
  • 浮点数类型:包括单精度浮点数 f32 和双精度浮点数 f64
  • 字符类型:使用单引号 '' 表示,大小为 4 个字节,支持 Unicode 字符集。
  • 字符串类型:使用双引号 "" 表示,是一个动态可变的 UTF-8 字符串。
  • 布尔类型:只有两个取值:truefalse
  • 数组类型:固定长度的数组,元素类型相同。
  • 元组类型:长度固定的有序集合,可以包含不同类型的元素。
  • 切片类型:指向某个数组或向量的一段连续的元素序列。
  • 向量类型:动态可变的数组,元素类型相同。
  • 指针类型:包括原始指针 *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 = "*"
  1. 实现代码
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();
}

你可能感兴趣的:(Rust,rust,开发语言,后端)