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); // 借用s1println!("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("[e-mail]"),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是一门强大而高效的语言，掌握它将使您在系统编程和并发编程领域游刃有余。