Rust 基础教程

Rust 编程语言教程

Rust是一门注重安全、并发和性能的系统编程语言。本文将从Rust的基本语法、常用功能到高级特性，详细介绍Rust的使用方法。

目录

1. 简介
2. 环境配置
3. 基础语法
   • 变量和常量
   • 数据类型
   • 函数
   • 控制流
4. 所有权和借用
   • 所有权
   • 借用
5. 结构体和枚举
   • 结构体
   • 枚举
6. 模块和包
7. 错误处理
8. 并发编程
9. 常用库和工具
10. 示例项目

简介

Rust是一门由Mozilla开发的系统编程语言，它的设计目标是提供内存安全、并发编程和高性能。Rust借鉴了许多现代编程语言的优点，同时引入了独特的所有权系统，以确保内存安全和线程安全。

环境配置

要开始使用Rust，首先需要安装Rust编译器和包管理工具Cargo。

安装Rust

可以通过Rust的官方安装工具 rustup 安装Rust。打开终端并运行以下命令：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

安装完成后，可以通过以下命令检查Rust是否安装成功：

rustc --version
cargo --version

创建第一个Rust项目

使用Cargo创建一个新的Rust项目：

cargo new hello_rust
cd hello_rust

项目目录结构如下：

hello_rust
├── Cargo.toml
└── src
    └── main.rs

Cargo.toml 文件是项目的配置文件，main.rs 文件是项目的入口点。

基础语法

变量和常量

Rust中的变量默认是不可变的，可以使用 let 关键字声明变量，使用 mut 关键字声明可变变量。常量使用 const 关键字声明。

fn main() {
    let x = 5; // 不可变变量
    let mut y = 10; // 可变变量
    const PI: f64 = 3.14159; // 常量
    println!("x: {}, y: {}, PI: {}", x, y, PI);
    y = 15;
    println!("Updated y: {}", y);
}

数据类型

Rust具有多种基本数据类型，包括标量类型和复合类型。

fn main() {
    // 标量类型
    let int_var: i32 = 10; // 整数
    let float_var: f64 = 3.14; // 浮点数
    let bool_var: bool = true; // 布尔值
    let char_var: char = 'R'; // 字符

    // 复合类型
    let tuple_var: (i32, f64, char) = (10, 3.14, 'R'); // 元组
    let array_var: [i32; 3] = [1, 2, 3]; // 数组

    println!("int_var: {}, float_var: {}, bool_var: {}, char_var: {}", int_var, float_var, bool_var, char_var);
    println!("tuple_var: {:?}", tuple_var);
    println!("array_var: {:?}", array_var);
}

函数

函数是Rust中的基本代码单元，使用 fn 关键字定义。

fn main() {
    let result = add(5, 10);
    println!("Result: {}", result);
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

控制流

Rust支持常见的控制流结构，如 if、loop、while 和 for。

fn main() {
    let number = 5;

    // if 表达式
    if number < 10 {
        println!("number is less than 10");
    } else {
        println!("number is 10 or greater");
    }

    // loop 循环
    let mut count = 0;
    loop {
        count += 1;
        if count == 3 {
            break;
        }
    }

    // while 循环
    while count < 5 {
        count += 1;
    }

    // for 循环
    for i in 0..5 {
        println!("i: {}", i);
    }
}

所有权和借用

所有权

Rust的所有权系统是其核心特性，确保内存安全。

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1的所有权被移动到s2
    // println!("{}", s1); // 这行代码将导致编译错误
    println!("{}", s2);
}

借用

借用可以让我们在不转移所有权的情况下使用变量。

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // 借用s1
    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

结构体和枚举

结构体

结构体用于定义复杂的数据类型。

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        username: String::from("someone"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
        active: true,
    };

    println!("Username: {}", user1.username);
}

枚举

枚举用于定义一组可能的值。

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let msg = Message::Write(String::from("Hello"));
    match msg {
        Message::Quit => println!("Quit"),
        Message::Move { x, y } => println!("Move to ({}, {})", x, y),
        Message::Write(text) => println!("Text: {}", text),
        Message::ChangeColor(r, g, b) => println!("Change color to ({}, {}, {})", r, g, b),
    }
}

模块和包

模块和包用于组织代码。

mod network {
    pub fn connect() {
        println!("Network connected");
    }

    pub mod server {
        pub fn start() {
            println!("Server started");
        }
    }
}

fn main() {
    network::connect();
    network::server::start();
}

错误处理

Rust使用 Result 和 Option 类型进行错误处理。

fn main() {
    let result = divide(4.0, 2.0);
    match result {
        Ok(v) => println!("Result: {}", v),
        Err(e) => println!("Error: {}", e),
    }
}

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("Division by zero"))
    } else {
        Ok(a / b)
    }
}

并发编程

Rust通过线程和消息传递模型支持并发编程。

use std::thread;
use std::sync::mpsc;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        tx.send(String::from("Hello from thread")).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Received: {}", received);
}

常用库和工具

Rust生态系统中有许多常用库和工具，例如 serde 用于序列化和反序列化，tokio 用于异步编程。

serde

# Cargo.toml
[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    age: u8,
}

fn main() {
    let p = Person {
        name: String::from("Alice"),
        age: 30,
    };

    let json = serde_json::to_string(&p).unwrap();
    println!("JSON: {}", json);

    let p2: Person = serde_json::from_str(&json

).unwrap();
    println!("Name: {}, Age: {}", p2.name, p2.age);
}

示例项目

最后，我们通过一个简单的示例项目来巩固学到的知识。

项目描述

创建一个命令行程序，它接受用户输入，并计算输入字符串的单词数量。

项目结构

word_count
├── Cargo.toml
└── src
    └── main.rs

代码实现

use std::env;
use std::fs;

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];

    let contents = fs::read_to_string(filename)
        .expect("Something went wrong reading the file");

    let word_count = contents.split_whitespace().count();

    println!("The file '{}' contains {} words", filename, word_count);
}

运行项目

cargo run text.txt

以上就是Rust编程语言的详细教程，从基础语法到高级特性，希望对您学习Rust有所帮助。Rust是一门强大而高效的语言，掌握它将使您在系统编程和并发编程领域游刃有余。