Comment créer une application CLI de base dans Rust

CLI (Command Line Interfaces) est crucial dans le développement de logiciels et l'administration système. Les CLI sont des programmes textuels légers qui offrent un moyen simplifié d'interagir avec les ordinateurs qui sont favorables pour les développeurs et les utilisateurs expérimentés pour de multiples cas d'utilisation, y compris l'automatisation, les scripts et la télécommande administration.

Rust gagne en popularité pour la création d'applications CLI. Rust fournit des fonctionnalités puissantes telles que le contrôle précis de l'allocation de mémoire et de la sécurité des threads, la sécurité de la mémoire, la concurrence et le parallélisme que vous pouvez exploiter pour créer de puissantes applications CLI. Rust se vante également d'un écosystème florissant de bibliothèques et de frameworks spécialement conçus pour la création d'applications CLI.

Commencer à créer des applications CLI avec Rust

Il existe plusieurs packages tiers pour créer des applications CLI dans Rust, notamment Taper, StructOpt, et Termion caisses. Ces caisses fournissent les fonctionnalités dont vous avez besoin pour développer des outils CLI modernes.

De plus, Rust fournit un std:: env crate dans sa bibliothèque standard qui fournit des fonctionnalités pour travailler avec des variables d'environnement et des arguments de ligne de commande. Le std:: env crate propose une gamme de méthodes et de types pour travailler avec des environnements de manière indépendante de la plate-forme.

En utilisant le std:: env crate, vos programmes Rust peuvent interagir avec l'environnement et adapter leur comportement en fonction de divers facteurs, y compris les variables d'environnement, les arguments de ligne de commande et le fonctionnement actuel annuaire.

Exécutez cette commande pour créer un nouveau projet Rust pour votre application CLI avec Cargo, l'outil de gestion de packages de Rust :

cargo nouveau crypto_cli

Vous apprendrez à créer une application CLI qui appelle l'API de Coinmarketcap avec le Reqwest caisse qui fournit des fonctionnalités pour la fabrication Requêtes HTTP dans Rust.

Ouvrez votre Cargaison.toml fichier et ajouter le demande et Tokyo crates aux dépendances de votre projet :

[dépendances]
Tokyo = { version = "1.15", caractéristiques = ["complet"] }
demande = { version = "0.11", caractéristiques = ["json"] }
serde = { version = "1.0", caractéristiques = ["dériver"] }
serde_json = "1.0"

Le Tokyo crate est une bibliothèque d'exécution asynchrone qui interagit avec demande pour la programmation asynchrone. Le serde et serde_json caisses aider avec Sérialisation et désérialisation JSON.

Dans le src dossier de votre projet Rust, créez api.rs et cli.rs fichiers où vous implémenterez les fonctionnalités d'appel d'API et de CLI.

toucher src/api.rs src/cli.rs

La commande doit créer les fichiers souhaités dans le répertoire de travail de votre projet. Après avoir écrit les fonctionnalités dans leurs fichiers désignés pour la séparation des préoccupations, vous appellerez les fonctions dans le principal fonction dans votre main.rs déposer.

Faire des requêtes API à l'API de CoinMarketCap avec Reqwest

API de CoinMarketCap vous permet d'accéder et d'intégrer des données de crypto-monnaie dans leurs applications. L'API fournit des points de terminaison pour les listes, les cotations du marché, les informations d'échange, les outils de conversion, les données historiques et les métadonnées.

Lorsque vous vous connectez, vous pouvez créer un compte CoinMarketCap et récupérer votre clé API sur la page du développeur de Coinmarketcap. Vous pouvez également vous référer à la documentation pour des instructions détaillées et des limites de taux.

Pour faire une demande d'API au /v2/cryptocurrency/quotes/latest point de terminaison qui renvoie la dernière cotation du marché pour une ou plusieurs crypto-monnaies, vous devrez définir le structs pour les données que vous souhaitez extraire de l'API et spécifiez les attributs avec le trait de dérivation de Serde.

Ensuite, vous pouvez demander une API au point de terminaison et utiliser le serde_json crate pour désérialiser les données JSON dans la structure afin de faciliter les opérations sur les types de données Rust.

Ici se trouve le définition de structure qui récupère le identifiant, nom, symbole, et citation données des crypto-monnaies spécifiées

#[dériver (déboguer, désérialiser, sérialiser)]
structureApiResponse {
 données: Données,
}
#[dériver (déboguer, désérialiser, sérialiser)]
structureDonnées {
// Ajoutez les champs dont vous avez besoin à partir de l'objet de données
#[serde (renommer = "1")]
 crypto_1: Crypto-monnaie,
#[serde (renommer = "2")]
 crypto_2: Crypto-monnaie,
#[serde (renommer = "3")]
 crypto_3: Crypto-monnaie,
#[serde (renommer = "4")]
 crypto_4: Crypto-monnaie,
}
#[dériver (déboguer, désérialiser, sérialiser)]
structureCrypto-monnaie {
 identifiant: u32,
 nom: Chaîne,
 symbole: Chaîne,
// Ajoutez d'autres champs si nécessaire
 citation: Citation,
}
#[dériver (déboguer, désérialiser, sérialiser)]
structureCitation {
 USD: Détails du devis,
}
#[dériver (déboguer, désérialiser, sérialiser)]
structureDétails du devis {
 prix: f64,
 volume_24h: f64,
// Ajoutez d'autres champs si nécessaire
}

L'API renvoie des données qui peuvent être plus que nécessaires, mais avec le serde crate, vous pouvez spécifier les données exactes dont vous avez besoin, comme indiqué ci-dessus.

Maintenant, vous pouvez demander le point de terminaison avec Reqwest en créant un nouveau client qui effectue la demande GET avec les paramètres requis.

utiliser demande:: Client ;
utiliser reqwest:: Erreur ;
pubasynchronefncrypto() -> Résultat {
laisser client = Client:: nouveau();
laisser URL = " https://pro-api.coinmarketcap.com/v2/cryptocurrency/quotes/latest";
laisser paramètres = [
 ("identifiant", "1,2,3,4"),
 ("convertir", "USD"), // Convertir les valeurs marchandes en USD
 ];
laisser réponse = client.get (url)
 .entête("X-CMC_PRO_API_KEY", "VOTRE CLÉ API ICI")
 .query(&params)
 .envoyer().attendre?;
 ;
laisser résultat: ApiResponse = serde_json:: from_str(&*response.text().attendre?;).déballer();
imprimez !("{:#?}", résultat);
D'accord(())
}

Le crypto est une fonction asynchrone tokio-enabled qui demande le point de terminaison avec le client.get fonction après avoir créé une instance client avec la Client:: nouveau méthode.

Le entête appel de fonction sur l'instance du générateur de requêtes prend votre clé API, le mettre en doute fonction prend les paramètres, et la envoyer fonction envoie la requête.

Le crypto la fonction désérialise la réponse JSON avec serde_json from_str méthode qui prend une chaîne JSON.

Finalement, le crypto La fonction affiche le résultat de l'opération de désérialisation sur la console.

Récupération des arguments CLI dans Rust

Dans ton cli.rs fichier, vous allez importer le crypto fonction de la api.rs fichier et appelez la fonction si l'utilisateur spécifie "crypto" comme argument lors de l'exécution du projet avec le course de fret commande.

Voici comment vous pouvez utiliser le std:: env fonction pour récupérer l'argument de la ligne de commande :

utiliser std:: env;
utiliser caisse:: api:: crypto;
pubasynchronefncli() {
laisser arguments: Vec<Chaîne> = env:: args().collect();
si args.len() > 1 && arguments[1] == "crypto" {
 crypto().attendre.déballer();
 } autre {
imprimez !("Commande non valide. Utilisation: cargo run crypto");
 }
}

Le cli fonction récupère tous les arguments de la ligne de commande avec la env:: args().collect() fonction. Le sinon L'instruction vérifie s'il existe un argument supplémentaire, "crypto". Si la condition est évaluée vraie, le cli la fonction appelle le crypto fonction; sinon, le cli La fonction imprime une chaîne sur la console.

Enfin, vous pouvez appeler le cli fonction dans le principal fonction. Vous devez ajouter le #[tokio:: main] attribut depuis principal les fonctions ne peuvent pas être asynchrones dans Rust.

mode API ;
mode cl;
utiliser caisse:: cli:: cli;
#[tokio:: main]
asynchronefnprincipal() {
 cli().attendre;
}

Le principal la fonction appelle le cli fonction avec le attendre fonction qui suspend l'exécution jusqu'au résultat d'une Avenir est prêt.

Voici le résultat de l'exécution du crypto de course de fret commande:

Vous pouvez créer des applications Web sophistiquées dans Rust

Rust est un langage de programmation polyvalent avec de nombreux cas d'utilisation et applications. Vous pouvez tirer parti de frameworks Web tiers comme Actix, Rocket et Warp pour créer des applications Web dans Rust. Ces frameworks fournissent la plupart des fonctionnalités nécessaires pour créer des applications Web modernes.