So erstellen Sie eine einfache CLI-App in Rust

CLI (Command Line Interfaces) ist in der Softwareentwicklung und Systemadministration von entscheidender Bedeutung. CLIs sind leichte textbasierte Programme, die eine optimierte Möglichkeit zur Interaktion mit Computern bieten, die günstig sind für Entwickler und Power-User gleichermaßen für mehrere Anwendungsfälle, einschließlich Automatisierung, Skripterstellung und Remote Verwaltung.

Rust erfreut sich beim Erstellen von CLI-Apps zunehmender Beliebtheit. Rust bietet leistungsstarke Funktionen wie eine differenzierte Kontrolle über die Speicherzuweisung und Thread-Sicherheit, Speichersicherheit, Parallelität und Parallelität, die Sie zum Erstellen leistungsstarker CLI-Apps nutzen können. Rust verfügt außerdem über ein florierendes Ökosystem von Bibliotheken und Frameworks, die speziell auf die Erstellung von CLI-Anwendungen zugeschnitten sind.

Erste Schritte beim Erstellen von CLI-Apps mit Rust

Es gibt mehrere Pakete von Drittanbietern zum Erstellen von CLI-Apps in Rust, darunter Klatschen, StructOpt, Und Begriff Kisten. Diese Kisten bieten die Funktionen, die Sie für die Entwicklung moderner CLI-Tools benötigen.

Außerdem bietet Rust eine std:: env crate in seiner Standardbibliothek, die Funktionen für die Arbeit mit Umgebungsvariablen und Befehlszeilenargumenten bietet. Der std:: env Crate bietet eine Reihe von Methoden und Typen für die plattformunabhängige Arbeit mit Umgebungen.

Verwendung der std:: env Mit Crate können Ihre Rust-Programme mit der Umgebung interagieren und ihr Verhalten basierend darauf anpassen verschiedene Faktoren, einschließlich Umgebungsvariablen, Befehlszeilenargumente und die aktuelle Funktionsweise Verzeichnis.

Führen Sie diesen Befehl aus, um mit Cargo, dem Paketverwaltungstool von Rust, ein neues Rust-Projekt für Ihre CLI-App zu erstellen:

Ladung neue crypto_cli

Sie erfahren, wie Sie eine CLI-Anwendung erstellen, die die API von Coinmarketcap aufruft Anfrage Kiste, die Funktionen zum Herstellen bietet HTTP-Anfragen in Rust.

Öffne dein Cargo.toml Datei und fügen Sie die hinzu Bitte Und Tokio Kisten zu den Abhängigkeiten Ihres Projekts:

[Abhängigkeiten]
Tokio = {Version = "1.15", Funktionen = ["voll"] }
Bitte = {Version = "0.11", Funktionen = [„json“] }
serde = {Version = "1.0", Funktionen = ["ableiten"] }
serde_json = "1.0"

Der Tokio crate ist eine asynchrone Laufzeitbibliothek, die mit interoperiert Bitte für asynchrone Programmierung. Der serde Und serde_json Kisten helfen dabei JSON-Serialisierung und Deserialisierung.

Im src Ordner Ihres Rust-Projekts erstellen api.rs Und cli.rs Dateien, in denen Sie den API-Aufruf und die CLI-Funktionen implementieren.

Berühren Sie src/api.rs src/cli.rs

Der Befehl sollte die gewünschten Dateien im Arbeitsverzeichnis Ihres Projekts erstellen. Nachdem Sie die Funktionen zur Trennung von Belangen in die dafür vorgesehenen Dateien geschrieben haben, rufen Sie die Funktionen in auf hauptsächlich Funktion in Ihrem main.rs Datei.

API-Anfragen an die API von CoinMarketCap mit Reqwest stellen

Die API von CoinMarketCap ermöglicht Ihnen den Zugriff auf Kryptowährungsdaten und deren Integration in ihre Anwendungen. Die API bietet Endpunkte für Listungen, Marktkurse, Börseninformationen, Konvertierungstools, historische Daten und Metadaten.

Wenn Sie sich anmelden, können Sie sich für ein CoinMarketCap-Konto anmelden und Ihren API-Schlüssel auf der Entwicklerseite von Coinmarketcap abrufen. Detaillierte Anweisungen und Ratenbeschränkungen finden Sie auch in der Dokumentation.

Um eine API-Anfrage an die zu stellen /v2/cryptocurrency/quotes/latest Endpunkt, der den neuesten Marktkurs für eine oder mehrere Kryptowährungen zurückgibt, müssen Sie definieren Strukturen für die Daten, die Sie aus der API extrahieren möchten, und geben Sie die Attribute mit Serdes Ableitungsmerkmal an.

Anschließend können Sie eine API für den Endpunkt anfordern und diese verwenden serde_json crate, um die JSON-Daten in die Struktur zu deserialisieren, um Operationen mit Rust-Datentypen zu vereinfachen.

Hier ist die Strukturdefinition das ruft die ab Ausweis, Name, Symbol, Und zitieren Daten der angegebenen Kryptowährungen

#[ableiten (Debuggen, Deserialisieren, Serialisieren)]
StrukturApiResponse {
 Daten: Daten,
}
#[ableiten (Debuggen, Deserialisieren, Serialisieren)]
StrukturDaten {
// Fügen Sie die benötigten Felder aus dem Datenobjekt hinzu
#[serde (umbenennen = "1")]
 crypto_1: Kryptowährung,
#[serde (umbenennen = "2")]
 crypto_2: Kryptowährung,
#[serde (umbenennen = "3")]
 crypto_3: Kryptowährung,
#[serde (umbenennen = "4")]
 crypto_4: Kryptowährung,
}
#[ableiten (Debuggen, Deserialisieren, Serialisieren)]
StrukturKryptowährung {
 Ausweis: u32,
 Name: Zeichenfolge,
 Symbol: Zeichenfolge,
// Weitere Felder nach Bedarf hinzufügen
 Zitat: Zitat,
}
#[ableiten (Debuggen, Deserialisieren, Serialisieren)]
StrukturZitieren {
 USD: QuoteDetails,
}
#[ableiten (Debuggen, Deserialisieren, Serialisieren)]
StrukturQuoteDetails {
 Preis: f64,
 Volumen_24h: f64,
// Weitere Felder nach Bedarf hinzufügen
}

Die API gibt möglicherweise mehr Daten zurück, als Sie benötigen, aber mit dem serde In der Kiste können Sie die genauen Daten angeben, die Sie benötigen, wie oben gezeigt.

Jetzt können Sie den Endpunkt mit Reqwest anfordern, indem Sie einen neuen Client erstellen, der die GET-Anfrage mit den erforderlichen Parametern stellt.

verwenden reqwest:: Kunde;
verwenden reqwest:: Fehler;
KneipeasynchronfnKrypto() -> Ergebnis {
lassen client = Client:: new();
lassen URL = " https://pro-api.coinmarketcap.com/v2/cryptocurrency/quotes/latest";
lassen Parameter = [
 ("Ausweis", "1,2,3,4"),
 ("Konvertieren", "US DOLLAR"), // Marktwerte in USD umrechnen
 ];
lassen Antwort = client.get (URL)
 .Header(„X-CMC_PRO_API_KEY“, „HIER IHR API-SCHLÜSSEL“)
 .query(&params)
 .schicken().erwarten?;
 ;
lassen Ergebnis: ApiResponse = serde_json:: from_str(&*response.text().erwarten?;).auspacken();
println!("{:#?}", Ergebnis);
OK(())
}

Der Krypto Funktion ist eine tokio-fähige asynchrone Funktion, die den Endpunkt mit anfordert client.get Funktion nach dem Erstellen einer Client-Instanz mit dem Kunde:: neu Methode.

Der Header Der Funktionsaufruf auf der Request Builder-Instanz übernimmt Ihren API-Schlüssel, den Anfrage Die Funktion übernimmt die Parameter und die schicken Funktion sendet die Anfrage.

Der Krypto Die Funktion deserialisiert die JSON-Antwort mit serde_json from_str Methode, die einen JSON-String aufnimmt.

Endlich, das Krypto Die Funktion gibt das Ergebnis des Deserialisierungsvorgangs auf der Konsole aus.

Abrufen von CLI-Argumenten in Rust

In deinem cli.rs Datei importieren Sie die Krypto Funktion aus dem api.rs Datei und rufen Sie die Funktion auf, wenn der Benutzer „Krypto“ als Argument beim Ausführen des Projekts mit angibt Frachtfahrt Befehl.

Hier erfahren Sie, wie Sie das verwenden können std:: env Funktion zum Abrufen des Arguments von der Befehlszeile:

verwenden std:: env;
verwenden Kiste:: api:: crypto;
Kneipeasynchronfncli() {
lassen Argumente: Vec<Zeichenfolge> = env:: args().collect();
Wenn args.len() > 1 && Argumente[1] == „Krypto“ {
 crypto().erwarten.auspacken();
 } anders {
println!("Ungültiger Befehl. Verwendung: Cargo-Run-Krypto);
 }
}

Der cli Die Funktion ruft alle Argumente von der Befehlszeile mit ab env:: args().collect() Funktion. Der ansonsten Die Anweisung prüft, ob es ein zusätzliches Argument gibt, „crypto“. Wenn die Bedingung wahr ist, wird die cli Funktion ruft die auf Krypto Funktion; ansonsten der cli Funktion gibt einen String an die Konsole aus.

Schließlich können Sie die anrufen cli Funktion in der hauptsächlich Funktion. Sie müssen das hinzufügen #[tokio:: main] Attribut seit hauptsächlich Funktionen können in Rust nicht asynchron sein.

Mod API;
Mod cli;
verwenden Kiste:: cli:: cli;
#[tokio:: main]
asynchronfnhauptsächlich() {
 cli().erwarten;
}

Der hauptsächlich Funktion ruft die auf cli Funktion mit der erwarten Funktion, die die Ausführung bis zum Ergebnis von a unterbricht Zukunft ist bereit.

Hier ist das Ergebnis der Ausführung Cargo-Run-Krypto Befehl:

Sie können in Rust anspruchsvolle Web-Apps erstellen

Rust ist eine vielseitige Programmiersprache mit vielen Anwendungsfällen und Anwendungen. Sie können Web-Frameworks von Drittanbietern wie Actix, Rocket und Warp nutzen, um Webanwendungen in Rust zu erstellen. Diese Frameworks bieten die meisten Funktionalitäten, die zum Erstellen moderner Web-Apps erforderlich sind.