Cargo: Rusts Build- und Paketmanager

RustRustBeginner
Jetzt üben

This tutorial is from open-source community. Access the source code

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

Willkommen bei Hello, Cargo. Dieser Lab ist Teil des Rust Buchs. Du kannst deine Rust-Fähigkeiten in LabEx üben.

In diesem Lab lernen wir über Cargo, das Build-System und Paketmanager von Rust, das Aufgaben wie das Erstellen von Code, die Abhängigkeitsverwaltung und das Herunterladen von Bibliotheken für Rust-Projekte vereinfacht.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust/FunctionsandClosuresGroup -.-> rust/function_syntax("Function Syntax") rust/FunctionsandClosuresGroup -.-> rust/expressions_statements("Expressions and Statements") subgraph Lab Skills rust/function_syntax -.-> lab-100385{{"Cargo: Rusts Build- und Paketmanager"}} rust/expressions_statements -.-> lab-100385{{"Cargo: Rusts Build- und Paketmanager"}} end

Hello, Cargo

Cargo ist das Build-System und Paketmanager von Rust. Die meisten Rust-Entwickler verwenden dieses Tool, um ihre Rust-Projekte zu verwalten, da Cargo für Sie viele Aufgaben erledigt, wie das Erstellen Ihres Codes, das Herunterladen der Bibliotheken, auf die Ihr Code zugreift, und das Erstellen dieser Bibliotheken. (Wir nennen die Bibliotheken, die Ihr Code benötigt, Abhängigkeiten.)

Die einfachsten Rust-Programme, wie die bisher von uns geschriebenen, haben keine Abhängigkeiten. Wenn wir das "Hello, world!"-Projekt mit Cargo gebaut hätten, würde es nur den Teil von Cargo verwenden, der das Erstellen Ihres Codes behandelt. Wenn Sie komplexere Rust-Programme schreiben, werden Sie Abhängigkeiten hinzufügen, und wenn Sie ein Projekt mit Cargo starten, wird das Hinzufügen von Abhängigkeiten viel einfacher.

Da der überwiegende Teil der Rust-Projekte Cargo verwendet, wird in diesem Buch davon ausgegangen, dass Sie auch Cargo verwenden. Cargo ist standardmäßig mit Rust installiert, wenn Sie die offiziellen Installationsprogramme aus "Installation" verwendet haben. Wenn Sie Rust auf andere Weise installiert haben, überprüfen Sie, ob Cargo installiert ist, indem Sie Folgendes in Ihrem Terminal eingeben:

cargo --version

Wenn Sie eine Versionsnummer sehen, haben Sie es! Wenn Sie einen Fehler wie "command not found" erhalten, lesen Sie die Dokumentation zu Ihrem Installationsverfahren, um zu bestimmen, wie Sie Cargo separat installieren können.

Ein Projekt mit Cargo erstellen

Lassen Sie uns ein neues Projekt mit Cargo erstellen und sehen, wie es sich von unserem ursprünglichen "Hello, world!"-Projekt unterscheidet. Navigieren Sie zurück in Ihr project-Verzeichnis (oder in das Verzeichnis, in dem Sie Ihre Code-Dateien gespeichert haben). Anschließend führen Sie auf jedem Betriebssystem Folgendes aus:

cd ~/project
cargo new hello_cargo
cd hello_cargo

Der erste Befehl erstellt ein neues Verzeichnis und Projekt namens hello_cargo. Wir haben unseren Projektnamen hello_cargo gewählt, und Cargo erstellt seine Dateien in einem Verzeichnis mit demselben Namen.

Gehen Sie in das Verzeichnis hello_cargo und listen Sie die Dateien auf. Sie werden sehen, dass Cargo zwei Dateien und ein Verzeichnis für uns erstellt hat: eine Datei namens Cargo.toml und ein Verzeichnis src mit einer Datei main.rs darin.

Es hat auch ein neues Git-Repository zusammen mit einer .gitignore-Datei initialisiert. Wenn Sie cargo new innerhalb eines bestehenden Git-Repositorys ausführen, werden keine Git-Dateien erstellt; Sie können dieses Verhalten überschreiben, indem Sie cargo new --vcs=git verwenden.

Hinweis: Git ist ein übliches Versionskontrollsystem. Sie können cargo new ändern, um ein anderes Versionskontrollsystem oder kein Versionskontrollsystem zu verwenden, indem Sie das Flag --vcs verwenden. Führen Sie cargo new --help aus, um die verfügbaren Optionen anzuzeigen.

Öffnen Sie Cargo.toml in Ihrem bevorzugten Texteditor. Es sollte ähnlich wie der Code in Listing 1-2 aussehen.

Dateiname: Cargo.toml

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"

[dependencies]

Listing 1-2: Inhalt von Cargo.toml, der von cargo new generiert wurde

Diese Datei ist im TOML (Tom's Obvious, Minimal Language)-Format, das das Konfigurationsformat von Cargo ist.

Die erste Zeile, [package], ist ein Abschnittstitel, der angibt, dass die folgenden Angaben eine Paketkonfiguration sind. Wenn wir mehr Informationen zu dieser Datei hinzufügen, werden wir weitere Abschnitte hinzufügen.

Die nächsten drei Zeilen legen die Konfigurationsinformationen fest, die Cargo benötigt, um Ihr Programm zu kompilieren: den Namen, die Version und die Rust-Edition, die verwendet werden soll. Wir werden im Anhang E über den Schlüssel edition sprechen.

Die letzte Zeile, [dependencies], ist der Beginn eines Abschnitts, in dem Sie alle Abhängigkeiten Ihres Projekts auflisten können. In Rust werden Code-Pakete als Crates bezeichnet. Für dieses Projekt werden wir keine weiteren Crates benötigen, aber wir werden dies im ersten Projekt im Kapitel 2, daher werden wir diesen Abhängigkeitsabschnitt dann verwenden.

Öffnen Sie nun src/main.rs und schauen Sie sich an:

Dateiname: src/main.rs

fn main() {
    println!("Hello, world!");
}

Cargo hat Ihnen ein "Hello, world!"-Programm generiert, genau wie das, das wir in Listing 1-1 geschrieben haben! Bisher unterscheiden sich unsere Projekt und das von Cargo generierte Projekt darin, dass Cargo den Code im src-Verzeichnis platziert hat und wir eine Cargo.toml-Konfigurationsdatei im obersten Verzeichnis haben.

Cargo erwartet, dass Ihre Quellcode-Dateien im src-Verzeichnis gespeichert sind. Das oberste Projektverzeichnis ist nur für README-Dateien, Lizenzhinweise, Konfigurationsdateien und alles andere, das nicht mit Ihrem Code zusammenhängt. Die Verwendung von Cargo hilft Ihnen, Ihre Projekte zu organisieren. Es gibt einen Platz für alles, und alles ist an seinem Platz.

Wenn Sie ein Projekt gestartet haben, das nicht Cargo verwendet, wie wir es mit dem "Hello, world!"-Projekt getan haben, können Sie es in ein Projekt umwandeln, das Cargo verwendet. Verschieben Sie den Projektcode in das src-Verzeichnis und erstellen Sie eine passende Cargo.toml-Datei.

Ein Cargo-Projekt bauen und ausführen

Schauen wir uns nun an, was sich ändert, wenn wir das "Hello, world!"-Programm mit Cargo bauen und ausführen! Aus Ihrem hello_cargo-Verzeichnis aus führen Sie den folgenden Befehl aus, um Ihr Projekt zu bauen:

$ cargo build
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

Dieser Befehl erstellt eine ausführbare Datei in target/debug/hello_cargo statt im aktuellen Verzeichnis. Da der Standardaufbau ein Debug-Aufbau ist, legt Cargo die Binärdatei in einem Verzeichnis namens debug ab. Sie können die ausführbare Datei mit diesem Befehl ausführen:

$./target/debug/hello_cargo
Hello, world!

Wenn alles funktioniert, sollte Hello, world! in der Konsole ausgegeben werden. Wenn Sie cargo build zum ersten Mal ausführen, erstellt Cargo auch eine neue Datei im obersten Verzeichnis: Cargo.lock. Diese Datei verfolgt die genauen Versionen der Abhängigkeiten in Ihrem Projekt. Dieses Projekt hat keine Abhängigkeiten, daher ist die Datei etwas spärlich. Sie müssen diese Datei niemals manuell ändern; Cargo verwaltet ihren Inhalt für Sie.

Wir haben gerade ein Projekt mit cargo build gebaut und es mit ./target/debug/hello_cargo ausgeführt, aber wir können auch cargo run verwenden, um den Code zu kompilieren und dann die resultierende ausführbare Datei in einem einzigen Befehl auszuführen:

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/hello_cargo`
Hello, world!

Das Verwenden von cargo run ist bequemer als das Erinnern, cargo build auszuführen und dann den gesamten Pfad zur Binärdatei zu verwenden, daher verwenden die meisten Entwickler cargo run.

Beachten Sie, dass wir diesmal keine Ausgabe gesehen haben, die angibt, dass Cargo hello_cargo kompiliert. Cargo hat erkannt, dass die Dateien nicht geändert wurden, daher hat es nicht neu gebaut, sondern nur die Binärdatei ausgeführt. Wenn Sie Ihren Quellcode geändert hätten, hätte Cargo das Projekt vor der Ausführung neu gebaut, und Sie hätten diese Ausgabe gesehen:

$ 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 bietet auch einen Befehl namens cargo check. Dieser Befehl überprüft Ihren Code schnell, um sicherzustellen, dass er kompiliert, erzeugt jedoch keine ausführbare Datei:

$ cargo check
   Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

Warum möchten Sie keine ausführbare Datei haben? Oft ist cargo check viel schneller als cargo build, weil es den Schritt der Erzeugung einer ausführbaren Datei überspringt. Wenn Sie Ihre Arbeit ständig während des Schreibens des Codes überprüfen, wird das Verwenden von cargo check den Prozess beschleunigen, Ihnen mitzuteilen, ob Ihr Projekt weiterhin kompiliert! Daher führen viele Rust-Entwickler periodisch cargo check aus, wenn sie ihren Code schreiben, um sicherzustellen, dass er kompiliert. Dann führen sie cargo build aus, wenn sie bereit sind, die ausführbare Datei zu verwenden.

Fassen wir zusammen, was wir bisher über Cargo gelernt haben:

  • Wir können ein Projekt mit cargo new erstellen.
  • Wir können ein Projekt mit cargo build bauen.
  • Wir können ein Projekt in einem Schritt bauen und ausführen mit cargo run.
  • Wir können ein Projekt bauen, ohne eine Binärdatei zu erzeugen, um Fehler zu überprüfen, mit cargo check.
  • Anstatt das Ergebnis des Builds im selben Verzeichnis wie unseren Code zu speichern, legt Cargo es im Verzeichnis target/debug ab.

Ein zusätzlicher Vorteil der Verwendung von Cargo ist, dass die Befehle unabhängig von dem Betriebssystem, auf dem Sie arbeiten, gleich sind. Daher werden wir ab diesem Punkt keine spezifischen Anweisungen mehr für Linux und macOS im Vergleich zu Windows geben.

Zum Release bauen

Wenn Ihr Projekt schließlich für die Veröffentlichung bereit ist, können Sie cargo build --release verwenden, um es mit Optimierungen zu kompilieren.

cargo build --release

Dieser Befehl erstellt eine ausführbare Datei in target/release statt in target/debug. Die Optimierungen machen Ihren Rust-Code schneller laufen, aber das Aktivieren der Optimierungen verlängert die Zeit, die es dauert, Ihr Programm zu kompilieren. Deshalb gibt es zwei verschiedene Profile: eines für die Entwicklung, wenn Sie schnell und oft neu bauen möchten, und eines für das Erstellen des endgültigen Programms, das Sie einem Benutzer geben werden, das nicht wiederholt neu gebaut werden wird und das so schnell wie möglich laufen wird. Wenn Sie die Laufzeit Ihres Codes benchmarken, stellen Sie sicher, dass Sie cargo build --release ausführen und mit der ausführbaren Datei in target/release benchmarken.

Cargo als Konvention

Bei einfachen Projekten bietet Cargo nicht viel mehr Wert als die reine Verwendung von rustc, aber seine Wertigkeit wird sich bei zunehmender Komplexität Ihrer Programme beweisen. Sobald Programme auf mehrere Dateien anwachsen oder Abhängigkeiten benötigen, ist es einfacher, Cargo zu verwenden, um den Build zu koordinieren.

Auch wenn das hello_cargo-Projekt einfach ist, verwendet es jetzt viel von den wirklichen Werkzeugen, die Sie in der restlichen Zeit Ihres Rust-Careers verwenden werden. Tatsächlich können Sie für jedes vorhandene Projekt die folgenden Befehle verwenden, um den Code mit Git herunterzuladen, in das Projektverzeichnis zu wechseln und zu bauen:

git clone example.org/someproject
cd someproject
cargo build

Weitere Informationen zu Cargo finden Sie in der Dokumentation unter https://doc.rust-lang.org/cargo.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Hello, Cargo-Labor abgeschlossen. Sie können in LabEx weitere Labs absolvieren, um Ihre Fähigkeiten zu verbessern.