深入学习Rust编程语言指南

需积分: 2 106 浏览量更新于2024-06-18 收藏 15.8MB PDF 举报

"Rust语言文档" Rust编程语言是一门专注于系统级编程、高性能以及内存安全的语言。这个文档，即《The Rust Programming Language》，由Steve Klabnik和Carol Nichols编写，并得到了Rust社区的贡献。它适用于Rust 1.67.1或更高版本（截至2023年2月9日发布）。为了安装或更新Rust，你可以参考第1章中的“Installation”部分。该书的HTML版在线可于https://doc.rust-lang.org/stable/book/找到，同时，通过rustup工具安装Rust后，运行`rustup docs --book`命令也可在本地查看。此外，还有多个社区翻译版本可供选择。纸质版和电子版书籍则可在NoStarch Press购买。对于想要更互动学习体验的读者，作者推荐了一个不同的Rust Book版本，其中包括测验、高亮显示、可视化等增强功能，可以在https://rust-book.cs.brown.edu 进行访问。序言中提到，Rust编程语言的核心理念是赋予程序员力量。无论你现在编写什么类型的代码，Rust都能帮助你实现更大的目标，进行更深入的编程。它的设计旨在让你能够编写出高效且安全的系统软件，同时避免了传统C++等语言中常见的内存管理和线程安全问题。 Rust的关键特性包括： 1. 所有权系统：这是Rust最独特的特性之一，它确保了内存管理的安全性，防止了悬挂指针和数据竞争等问题。 2. 生命周期：Rust的所有权系统中的一部分，用于追踪引用的有效时间，确保对象在使用时总是有效的。 3. 借用与引用：Rust的借用规则允许在不拥有所有权的情况下访问数据，但同时也限制了借用的范围和方式，保证了内存安全。 4. 类型系统：Rust有强大的静态类型系统，可以检测许多潜在的错误并在编译时解决。 5. 模式匹配：通过模式匹配，你可以更方便地处理不同类型的数据和结构，同时在解构复杂数据结构时保持代码整洁。 6. 并发性：Rust的并发模型基于所有权和线程局部性，使得编写线程安全的代码变得相对简单。 7. 零成本抽象：Rust允许在不影响性能的情况下创建抽象，这意味着你可以构建复杂的系统而不必担心性能损失。 8. 宏和元编程：Rust的宏系统允许你在编译时进行代码生成，增加了语言的灵活性。《The Rust Programming Language》文档是学习和理解Rust语言的权威资源，覆盖了从基础知识到高级特性的全面内容，适合初学者和经验丰富的开发者阅读。通过深入学习，你可以掌握Rust的强大功能，并利用其来构建高效、安全的软件系统。

2023/12/9 11:11

The Rust Programming Language

https://doc.rust-lang.org/book/print.html

16/624

Hello, Cargo!

Cargo is Rust’s build system and package manager. Most Rustaceans use this tool to manage

their Rust projects because Cargo handles a lot of tasks for you, such as building your code,

downloading the libraries your code depends on, and building those libraries. (We call the

libraries that your code needs dependencies.)

The simplest Rust programs, like the one we’ve written so far, don’t have any dependencies.

If we had built the “Hello, world!” project with Cargo, it would only use the part of Cargo that

handles building your code. As you write more complex Rust programs, you’ll add

dependencies, and if you start a project using Cargo, adding dependencies will be much

easier to do.

Because the vast majority of Rust projects use Cargo, the rest of this book assumes that

you’re using Cargo too. Cargo comes installed with Rust if you used the oﬃcial installers

discussed in the “Installation” section. If you installed Rust through some other means, check

whether Cargo is installed by entering the following in your terminal:

If you see a version number, you have it! If you see an error, such as

command not found

look at the documentation for your method of installation to determine how to install Cargo

separately.

Creating a Project with Cargo

Let’s create a new project using Cargo and look at how it diﬀers from our original “Hello,

world!” project. Navigate back to your projects directory (or wherever you decided to store

your code). Then, on any operating system, run the following:

The ﬁrst command creates a new directory and project called hello_cargo. We’ve named our

project hello_cargo, and Cargo creates its ﬁles in a directory of the same name.

Go into the hello_cargo directory and list the ﬁles. You’ll see that Cargo has generated two

ﬁles and one directory for us: a Cargo.toml ﬁle and a src directory with a main.rs ﬁle inside.

It has also initialized a new Git repository along with a .gitignore ﬁle. Git ﬁles won’t be

generated if you run

cargo new

within an existing Git repository; you can override this

behavior by using

cargo new --vcs=git

$ cargo --version

$ cargo new hello_cargo

$ cd hello_cargo

2023/12/9 11:11

The Rust Programming Language

https://doc.rust-lang.org/book/print.html

18/624

Cargo expects your source ﬁles to live inside the src directory. The top-level project directory

is just for README ﬁles, license information, conﬁguration ﬁles, and anything else not

related to your code. Using Cargo helps you organize your projects. There’s a place for

everything, and everything is in its place.

If you started a project that doesn’t use Cargo, as we did with the “Hello, world!” project, you

can convert it to a project that does use Cargo. Move the project code into the src directory

and create an appropriate Cargo.toml ﬁle.

Building and Running a Cargo Project

Now let’s look at what’s diﬀerent when we build and run the “Hello, world!” program with

Cargo! From your hello_cargo directory, build your project by entering the following

command:

This command creates an executable ﬁle in target/debug/hello_cargo (or

target\debug\hello_cargo.exe on Windows) rather than in your current directory. Because the

default build is a debug build, Cargo puts the binary in a directory named debug. You can

run the executable with this command:

If all goes well,

Hello, world!

should print to the terminal. Running

cargo build

for the

ﬁrst time also causes Cargo to create a new ﬁle at the top level: Cargo.lock. This ﬁle keeps

track of the exact versions of dependencies in your project. This project doesn’t have

dependencies, so the ﬁle is a bit sparse. You won’t ever need to change this ﬁle manually;

Cargo manages its contents for you.

We just built a project with

cargo build

and ran it with

./target/debug/hello_cargo

, but

we can also use

cargo run

to compile the code and then run the resultant executable all in

one command:

Using

cargo run

is more convenient than having to remember to run

cargo build

and

then use the whole path to the binary, so most developers use

cargo run

$ cargo build

Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)

Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

$ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on Windows

Hello, world!

$ cargo run

Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs

Running `target/debug/hello_cargo`

Hello, world!

2023/12/9 11:11

The Rust Programming Language

https://doc.rust-lang.org/book/print.html

19/624

Notice that this time we didn’t see output indicating that Cargo was compiling

hello_cargo

Cargo ﬁgured out that the ﬁles hadn’t changed, so it didn’t rebuild but just ran the binary. If

you had modiﬁed your source code, Cargo would have rebuilt the project before running it,

and you would have seen this output:

Cargo also provides a command called

cargo check

. This command quickly checks your

code to make sure it compiles but doesn’t produce an executable:

Why would you not want an executable? Often,

cargo check

is much faster than

cargo

build

because it skips the step of producing an executable. If you’re continually checking

your work while writing the code, using

cargo check

will speed up the process of letting

you know if your project is still compiling! As such, many Rustaceans run

cargo check

periodically as they write their program to make sure it compiles. Then they run

cargo

build

when they’re ready to use the executable.

Let’s recap what we’ve learned so far about Cargo:

We can create a project using

cargo new

We can build a project using

cargo build

We can build and run a project in one step using

cargo run

We can build a project without producing a binary to check for errors using

cargo

check

Instead of saving the result of the build in the same directory as our code, Cargo stores

it in the target/debug directory.

An additional advantage of using Cargo is that the commands are the same no matter which

operating system you’re working on. So, at this point, we’ll no longer provide speciﬁc

instructions for Linux and macOS versus Windows.

Building for Release

When your project is ﬁnally ready for release, you can use

cargo build --release

compile it with optimizations. This command will create an executable in target/release

instead of target/debug. The optimizations make your Rust code run faster, but turning them

on lengthens the time it takes for your program to compile. This is why there are two

$ cargo run

Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)

Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs

Running `target/debug/hello_cargo`

Hello, world!

$ cargo check

Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)

Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

剩余623页未读，继续阅读

WSSWWWSSW

粉丝: 0
资源: 13

深入学习Rust编程语言指南

Rust程序设计语言，pdf文件

Rust编程语言.pdf

Rust Essentials.pdf

The Rust Programming Language.pdf

Rust Language Cheat Sheet.pdf

Rust全栈开发.pdf

Rust异步编程.pdf

rust-book.pdf

Rust使用教程.pdf

Rust in TiKV.pdf

最新资源