Beginnen Sie mit Rost: Set up und Ihrem ersten CLI -Werkzeug – ein Anfängerhandbuch

Eine beliebte Programmiersprache in den letzten Jahren, da sie Sicherheit und hohe Leistung kombiniert und in vielen Anwendungen verwendet werden kann. Es kombiniert die positiven Eigenschaften von C und C ++ mit der modernen Syntax und Einfachheit anderer Programmiersprachen wie Python. In diesem Artikel werden wir einen Schritt-für-Schritt-Blick auf die Set up von Rost auf verschiedenen Betriebssystemen werfen und eine einfache Befehlszeilenschnittstelle einrichten, um die Struktur und Funktionalität von Rust zu verstehen.

Rost installieren – Schritt für Schritt

Unabhängig vom Betriebssystem ist es dank des offiziellen Installationsprogramms recht einfach, Rost zu installieren rustupwas kostenlos auf der verfügbar ist Rost Webseite. Dies bedeutet, dass die Set up nur wenige Schritte dauert und sich nur für die verschiedenen Betriebssysteme nur geringfügig unterscheidet.

Rost unter Home windows installieren

In Home windows steuert der Installationsprogramm die Set up vollständig und Sie können die folgenden Schritte ausführen:

1. Gehen Sie zum Unterabschnitt „Set up“ auf der offiziellen Rust -Web site (https://www.rust-lang.org/instruments/set up) und laden Sie die herunter rustup-init.exe Datei dort. Die Web site erkennt das zugrunde liegende Betriebssystem so an, dass die entsprechenden Vorschläge für das verwendete System direkt gemacht werden.
2. Sobald der Obtain abgeschlossen ist, ist der rustup-init.exe Datei kann ausgeführt werden. Eine Befehlszeile mit verschiedenen Installationsanweisungen wird dann geöffnet.
3. Drücken Sie die Eingabetaste, um die Standardinstallation auszuführen, um Rost zu installieren. Dies schließt auch die folgenden Instruments ein:
   • rustc ist der Compiler, der den Code und die Überprüfung von Fehlern vor der Ausführung überprüft.
   • cargo Ist Rust’s Construct- und Paketmanagement -Software.
   • rustup ist der Versionsleiter.

Nach erfolgreicher Set up sollte Rost automatisch in Ihrem verfügbar sein PATH. Dies kann leicht in PowerShell oder CMD unter Verwendung der folgenden Befehle überprüft werden:

rustc --version cargo --version

Wenn „Rustc“ und „Fracht“ in der Ausgabe mit den jeweiligen Versionsnummern angezeigt werden, battle die Set up erfolgreich. Wenn der Befehl jedoch nicht gefunden wird, kann dies auf die Umgebungsvariablen zurückzuführen sein. Um diese zu überprüfen, können Sie den Pfad „Dieser PC -> Eigenschaften -> erweiterte Systemeinstellungen -> Umgebungsvariablen“ befolgen. Dort dort sollten Sie sicherstellen PATH Variable.

Installieren von Rost unter Ubuntu/Linux

In Linux kann Rost über das Terminal vollständig installiert werden, ohne etwas von der Rust -Web site herunterladen zu müssen. Um Rost zu installieren, müssen die folgenden Schritte durchgeführt werden:

1. Öffnen Sie beispielsweise das Terminal mit der Schlüsselkombination Strg + Alt + T.
2. Um Rost zu installieren, wird der folgende Befehl ausgeführt:

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

3. Sie werden dann gefragt, ob die Set up gestartet werden soll. Dies kann bestätigt werden, indem beispielsweise „1“ (Normal) eingegeben wird. Alle erforderlichen Pakete werden dann heruntergeladen und die Umgebung ist eingerichtet.
4. Möglicherweise müssen Sie den Pfad manuell einstellen. In diesem Fall können Sie diesen Befehl zum Beispiel verwenden:

supply $HOME/.cargo/env

Nach Abschluss der Set up können Sie überprüfen, ob alles richtig funktioniert hat. Dazu können Sie die Versionen von RustC und Fracht explizit anzeigen:

rustc --version cargo --version

Installieren von Rost unter MacOS

Es gibt verschiedene Möglichkeiten, Rost auf MacOS zu installieren. Wenn Sie Homebrew installiert haben, können Sie dies einfach verwenden, um Rust zu installieren, indem Sie den folgenden Befehl ausführen:

brew set up rustup rustup-init

Alternativ können Sie Rost auch direkt mit diesem Skript installieren:

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

Während der Set up werden Sie gefragt, ob Sie die Standardinstallation ausführen möchten. Sie können dies einfach bestätigen, indem Sie die Eingabetaste drücken. Unabhängig von der ausgewählten Variante können Sie die Set up überprüfen, indem Sie die Model von Rust anzeigen, um sicherzustellen, dass alles funktioniert hat:

rustc --version 
cargo --version

Erstellen eines Rust -Projekts mit Fracht

Während der Set up von Rost sind Sie wahrscheinlich bereits auf die gestoßen cargo Programm. Dies ist der offizielle Paketmanager und das Construct -Rostsystem und vergleichbar mit pip in Python. cargo führt unter anderem die folgenden Aufgaben aus:

• Initialisierung eines Projekts
• Verwaltung von Abhängigkeiten
• Kompilieren des Codes
• Ausführung von Assessments
• Optimierung von Builds

Auf diese Weise können Sie vollständige Projekte in Rost verwalten, ohne sich mit komplizierten Construct -Skripten befassen zu müssen. Es hilft Ihnen auch, schnell und einfach neue Projekte einzurichten, die dann mit dem Leben gefüllt werden können.

Für unser Beispiel werden wir ein neues Projekt erstellen. Dazu gehen wir zum Terminal und navigieren zu einem Ordner, in dem wir ihn speichern möchten. Anschließend führen wir den folgenden Befehl aus, um ein neues Rust -Projekt zu erstellen:

cargo new json_viewer --bin

Wir nennen dieses Projekt json_viewer Weil wir ein CLI -Software erstellen, mit dem wir zum Öffnen und Verfahren verwendet werden können JSON Dateien. Der --bin Die Possibility gibt an, dass wir ein ausführbares Programm und keine Bibliothek erstellen möchten. Sie sollten nun in der Lage sein, die folgende Ordnerstruktur in Ihrem Verzeichnis zu sehen, nachdem Sie den Befehl ausgeführt haben:

json_viewer/ 
├── Cargo.toml # Undertaking configuration 
└── src 
     └── most important.rs # File for Rust Code

Jedes neue Projekt hat diese Struktur. Cargo.toml Enthält alle Abhängigkeiten und Metadaten Ihres Projekts, wie den Namen, die verwendeten Bibliotheken oder die Model. Der src/most important.rsAndererseits enthält später den tatsächlichen Rostcode, der dann die Schritte definiert, die beim Starten des Programms ausgeführt werden.

Zunächst können wir hier eine einfache Funktion definieren, die eine Ausgabe im Terminal erzeugt:

fn most important() { 
     println!("Hey, Rust CLI-Software!"); 
}

Das Programm kann leicht vom Terminal mithilfe von Verwendung aufgerufen werden cargo:

cargo run

Damit dieser Aufruf zur Arbeit ist, muss sichergestellt werden, dass Sie sich im Hauptverzeichnis des Projekts befinden, dh wo die Cargo.toml Datei wird gespeichert. Wenn alles korrekt eingerichtet und ausgeführt wurde, erhalten Sie diese Ausgabe:

Hey, Rust CLI-Software!

Mit diesen wenigen Schritten haben Sie gerade Ihr erstes erfolgreiches Rust -Projekt erstellt, auf dem wir im nächsten Abschnitt aufbauen können.

Erstellen eines CLI -Werkzeugs: Einfacher JSON -Parser

Jetzt füllen wir das Projekt mit dem Leben aus und erstellen ein Programm, mit dem JSON -Dateien gelesen und ihre Inhalte auf strukturierte Weise im Terminal ausgeben können.

Der erste Schritt besteht darin, die Abhängigkeiten zu definieren, dh die Bibliotheken, die wir im Verlauf des Projekts verwenden werden. Diese werden in der gespeichert Cargo.toml Datei. In Rost sind die sogenannten Kisten mit Bibliotheken oder Modulen vergleichbar, die bestimmte vordefinierte Funktionen bieten. Zum Beispiel können sie aus wiederverwendbarem Code bestehen, das von anderen Entwicklern verfasst wurde.

Wir brauchen die folgenden Kisten für unser Projekt:

• serde ermöglicht die Serialisierung und Deserialisierung von Datenformaten wie z. JSON oder Yaml.
• serde_jsonAndererseits ist eine Erweiterung, die speziell für die Arbeit mit JSON -Dateien entwickelt wurde.

Damit Ihr Projekt auf diese Kisten zugreifen kann, müssen sie in der gespeichert werden Cargo.toml Datei. Dies sieht unmittelbar nach dem Erstellen des Projekts so aus:

(package deal) 
identify = "json_viewer" 
model = "0.1.0" 
version = "2021" 

(dependencies)

Wir können jetzt die erforderlichen Kisten in die hinzufügen (dependencies) Abschnitt. Hier definieren wir auch die zu verwendende Model:

(dependencies) 
serde = "1.0" 
serde_json = "1.0"

Um sicherzustellen, dass die zusätzlichen Abhängigkeiten im Projekt verfügbar sind, müssen sie zunächst heruntergeladen und erstellt werden. Dazu kann der folgende Terminalbefehl im Hauptverzeichnis ausgeführt werden:

cargo construct

Während der Ausführung, cargo Sucht nach den Abhängigkeiten und den angegebenen Versionen, um sie herunterzuladen. Diese Kisten werden dann zusammen mit dem Code zusammengestellt und zwischengespeichert, damit sie für den nächsten Construct nicht erneut heruntergeladen werden müssen.

Wenn diese Schritte funktioniert haben, sind wir jetzt bereit, den tatsächlichen Rostcode zu schreiben, der die JSON -Datei öffnet und verarbeitet. Dazu können Sie die öffnen src/most important.rs Datei und ersetzen Sie den vorhandenen Inhalt durch diesen Code:

use std::fs;
use serde_json::Worth;
use std::env;

fn most important() {
    // Test arguments
    let args: Vec<String> = env::args().acquire();
    if args.len() < 2 {
        println!(“Please specify the trail to your file.”);
        return;
    }

    // Learn in File
    let file_path = &args(1);
    let file_content = fs::read_to_string(file_path)
        .count on(“File couldn't be learn.”);

    // Parse JSON
    let json_data: Worth = serde_json::from_str(&file_content)
        .count on(“Invalid JSON format.”);

    // Print JSON
    println!(" JSON-content:n{}”, json_data);
}

Der Code folgt folgende Schritte:

1. Argumente überprüfen:
   • Wir lesen die Argumente aus der Befehlszeile über env::args().
   • Der Benutzer muss den Pfad zur JSON -Datei beim Begin angeben.
2. Lesen Sie die Datei:
   • Mit Hilfe von fs::read_to_string()Der Inhalt der Datei wird in eine Zeichenfolge gelesen.
3. JSON analysieren:
   • Die Kiste serde_json Konvertiert die Zeichenfolge in ein Rust -Objekt mit dem Typwert.
4. Formatausgabe:
   • Der Inhalt wird in der Konsole lesbar ausgegeben.

Um das Software zu testen, können Sie beispielsweise eine Testdatei im Projektverzeichnis unter dem Namen erstellen examples.json:

{
  "identify": "Alice",
  "age": 30,
  "abilities": ("Rust", "Python", "Machine Studying")
}

Das Programm wird dann mithilfe der Ausführung cargo run und der Pfad zur JSON -Datei ist ebenfalls definiert:

cargo run ./instance.json

Dies bringt uns zum Ende unseres ersten Projekts in Rust und wir haben erfolgreich ein einfaches CLI -Software erstellt, mit dem JSON -Dateien gelesen und an der Befehlszeile ausgegeben werden können.

Das sollten Sie mitnehmen

• Die Set up von Rost ist in vielen Betriebssystemen schnell und einfach. Die anderen benötigten Komponenten sind bereits installiert.
• Mit Hilfe von cargoein leeres Projekt kann direkt erstellt werden, das die erforderlichen Dateien enthält und in denen Sie mit dem Schreiben von Rostcode beginnen können
• Bevor Sie anfangen ProgrammierungSie sollten die Abhängigkeiten eingeben und sie mit dem Befehl Construct herunterladen.
• Nachdem alles eingerichtet ist, können Sie mit der tatsächlichen Programmierung beginnen.