詞彙表

製品（Artifact）

An artifact is the file or set of files created as a result of the compilation process. This includes linkable libraries, executable binaries, and generated documentation.

Cargo

Cargo is the Rust package manager, and the primary topic of this book.

Cargo.lock

請參見 鎖定檔。

Cargo.toml

請參見 清單。

軟體箱（Crate）

A Rust crate is either a library or an executable program, referred to as either a library crate or a binary crate, respectively.

Every target defined for a Cargo package is a crate.

Loosely, the term crate may refer to either the source code of the target or to the compiled artifact that the target produces. It may also refer to a compressed package fetched from a registry.

The source code for a given crate may be subdivided into modules.

版次（Edition）

A Rust edition is a developmental landmark of the Rust language. The edition of a package is specified in the Cargo.toml manifest, and individual targets can specify which edition they use. See the Edition Guide for more information.

功能（Feature）

The meaning of feature depends on the context:

• A feature is a named flag which allows for conditional compilation. A feature can refer to an optional dependency, or an arbitrary name defined in a Cargo.toml manifest that can be checked within source code.

• Cargo has unstable feature flags which can be used to enable experimental behavior of Cargo itself.

• Rust 編譯器與 Rustdoc 擁有各自的不穩定功能旗標（請參見《不穩定手冊》與《Rustdoc 手冊》）。

• CPU targets have target features which specify capabilities of a CPU.

索引（Index）

The index is the searchable list of crates in a registry.

鎖定檔（Lock file）

The Cargo.lock lock file is a file that captures the exact version of every dependency used in a workspace or package. It is automatically generated by Cargo. See Cargo.toml vs Cargo.lock.

清單（Manifest）

A manifest is a description of a package or a workspace in a file named Cargo.toml.

A virtual manifest is a Cargo.toml file that only describes a workspace, and does not include a package.

成員（Member）

A member is a package that belongs to a workspace.

模組（Module）

Rust’s module system is used to organize code into logical units called modules, which provide isolated namespaces within the code.

The source code for a given crate may be subdivided into one or more separate modules. This is usually done to organize the code into areas of related functionality or to control the visible scope (public/private) of symbols within the source (structs, functions, and so on).

A Cargo.toml file is primarily concerned with the package it defines, its crates, and the packages of the crates on which they depend. Nevertheless, you will see the term “module” often when working with Rust, so you should understand its relationship to a given crate.

軟體包（Package）

A package is a collection of source files and a Cargo.toml manifest file which describes the package. A package has a name and version which is used for specifying dependencies between packages.

A package contains multiple targets, each of which is a crate. The Cargo.toml file describes the type of the crates (binary or library) within the package, along with some metadata about each one — how each is to be built, what their direct dependencies are, etc., as described throughout this book.

The package root is the directory where the package’s Cargo.toml manifest is located. (Compare with workspace root.)

The package ID specification, or SPEC, is a string used to uniquely reference a specific version of a package from a specific source.

Small to medium sized Rust projects will only need a single package, though it is common for them to have multiple crates.

Larger projects may involve multiple packages, in which case Cargo workspaces can be used to manage common dependencies and other related metadata between the packages.

軟體包管理器（Package manager）

Broadly speaking, a package manager is a program (or collection of related programs) in a software ecosystem that automates the process of obtaining, installing, and upgrading artifacts. Within a programming language ecosystem, a package manager is a developer-focused tool whose primary functionality is to download library artifacts and their dependencies from some central repository; this capability is often combined with the ability to perform software builds (by invoking the language-specific compiler).

Cargo is the package manager within the Rust ecosystem. Cargo downloads your Rust package’s dependencies (artifacts known as crates), compiles your packages, makes distributable packages, and (optionally) uploads them to crates.io, the Rust community’s package registry.

軟體包註冊表（Package registry）

請參見 註冊表。

專案（Project）

軟體包的另一個名稱。

註冊表（Registry）

A registry is a service that contains a collection of downloadable crates that can be installed or used as dependencies for a package. The default registry in the Rust ecosystem is crates.io. The registry has an index which contains a list of all crates, and tells Cargo how to download the crates that are needed.

Source

A source is a provider that contains crates that may be included as dependencies for a package. There are several kinds of sources:

• 註冊表來源（Registry source） — 請參見註冊表。
• Local registry source — A set of crates stored as compressed files on the filesystem. See Local Registry Sources.
• Directory source — A set of crates stored as uncompressed files on the filesystem. See Directory Sources.
• Path source — An individual package located on the filesystem (such as a path dependency) or a set of multiple packages (such as path overrides).
• Git source — Packages located in a git repository (such as a git dependency or git source).

See Source Replacement for more information.

規範（Spec）

請參見軟體包 ID 規範。

目標（Target）

目標（target） 一詞的含義取決於上下文：

• Cargo 目標（Cargo Target） — Cargo 軟體包 是由 目標 組成的，這些目標對應到將會生成的 製品。軟體包可以擁有程式庫、執行檔、範例、測試與基準測試目標。目標列表是在 Cargo.toml 清單 中設定的，通常會根據來源檔的目錄配置自動推斷。

• 目標目錄（Target Directory） — Cargo 將建置製品放置在 目標 目錄中。預設情況下，這是位於 工作空間 根目錄下名為 target 的目錄，若未使用工作空間，則位於軟體包根目錄。此目錄可透過 --target-dir 命令行選項、CARGO_TARGET_DIR 環境變數或 build.target-dir 組態選項來變更。更多資訊請參見建置快取文件。

• 目標架構（Target Architecture） — 建置製品的作業系統與機器架構通常被稱為 目標 。

• Target Triple — A triple is a specific format for specifying a target architecture. Triples may be referred to as a target triple which is the architecture for the artifact produced, and the host triple which is the architecture that the compiler is running on. The target triple can be specified with the --target command-line option or the build.target config option. The general format of the triple is <arch><sub>-<vendor>-<sys>-<abi> where:

  • arch = The base CPU architecture, for example x86_64, i686, arm, thumb, mips, etc.
  • sub = The CPU sub-architecture, for example arm has v7, v7s, v5te, etc.
  • vendor = The vendor, for example unknown, apple, pc, nvidia, etc.
  • sys = The system name, for example linux, windows, darwin, etc. none is typically used for bare-metal without an OS.
  • abi = The ABI, for example gnu, android, eabi, etc. Some parameters may be omitted. Run rustc --print target-list for a list of supported targets.

測試目標（Test Target）

Cargo test targets generate binaries which help verify proper operation and correctness of code. There are two types of test artifacts:

• Unit test — A unit test is an executable binary compiled directly from a library or a binary target. It contains the entire contents of the library or binary code, and runs #[test] annotated functions, intended to verify individual units of code.
• Integration test target — An integration test target is an executable binary compiled from a test target which is a distinct crate whose source is located in the tests directory or specified by the [[test]] table in the Cargo.toml manifest. It is intended to only test the public API of a library, or execute a binary to verify its operation.

工作空間（Workspace）

A workspace is a collection of one or more packages that share common dependency resolution (with a shared Cargo.lock lock file), output directory, and various settings such as profiles.

A virtual workspace is a workspace where the root Cargo.toml manifest does not define a package, and only lists the workspace members.

The workspace root is the directory where the workspace’s Cargo.toml manifest is located. (Compare with package root.)