Créer une application de gestion de recettes
Le langage de programmation Rust est unique par rapport aux autres langages. Il est également extrêmement simple de créer des applications puissantes avec seulement quelques lignes de code. Ici, je vais démontrer à quel point il est facile de créer une application dans Rust en vous montrant comment créer un gestionnaire de recettes simple.
Sommaire
Configuration de Rust
Avant de pouvoir utiliser Rust, nous devons l'installer sur notre système. Heureusement, nous pouvons le faire en quelques étapes seulement :
En tant que personne plus habituée à utiliser Visual Studio, j'ai trouvé que l'utilisation de VS Code for Rust est beaucoup plus efficace. L'interpréteur Rust pour VS Code est mis à jour beaucoup plus souvent. Le processus de configuration réel est beaucoup plus détaillé, mais je n'y consacrerai pas trop de temps ici, car le guide mentionné fait du bon travail en vous donnant un moyen étape par étape d'installer Rust sur votre système.
Définir les exigences de notre programme
Conformément aux normes standard du cycle de développement de programmes, nous devons définir ce que notre programme doit faire avant de commencer à le coder. Cela nous donne un aperçu de ce que nous devons y inclure. À ce titre, voici les fonctionnalités de base dont nous avons besoin de notre programme :
- Ajouter de nouvelles recettes
- Voir toutes les recettes
- Afficher une recette spécifique
- Modifier les recettes existantes
- Supprimer des recettes
- Enregistrer les recettes dans un fichier
- Charger des recettes à partir d'un fichier
Cela semble être une configuration assez simple pour ce programme, et son écriture ne devrait pas être trop compliquée. Allons-y !
Configuration de notre dossier et de nos fichiers
La première chose que nous devons faire est de créer un dossier pour notre projet et de l'ouvrir dans une fenêtre de terminal. Cela peut différer selon le système d'exploitation, mais la plupart d'entre eux nous permettent de cliquer avec le bouton droit sur un dossier et de « Ouvrir dans le terminal ». Une fois cela fait, nous devons entrer la commande :
cargo new recipe_manager Cela crée un nouveau package avec toutes les dépendances dont nous avons besoin pour coder dans Rust. Une fois la commande cargo terminée, la fenêtre du terminal devrait ressembler à ceci :
La prochaine chose que nous devons faire est d'ouvrir notre dossier dans VS Code. C'est aussi simple que d'ouvrir VS Code, d'appuyer sur la commande « Fichier » et d'accéder à « Ouvrir le dossier » :
Cela nous donnera une fenêtre de projet qui ressemble un peu à ceci :
Une fois que nous avons configuré notre dossier, nous devrons créer quelques fichiers qui feront le gros du travail pour notre projet. Puisque nous voulons l'interface utilisateur, le gestionnaire d'applications et la définition de la recette dans des fichiers différents, nous allons créer trois fichiers qui contiendront le code de ces éléments séparément. Nous pouvons le faire en cliquant à nouveau sur le menu « Fichier » et en sélectionnant « Nouveau fichier ». Nous renommerons ces fichiers en recette.rs, manager.rs et ui.rs. Lorsque nous avons terminé, notre fenêtre de projet devrait ressembler à ceci :
Nous n’avons pas encore terminé la configuration. La prochaine chose que nous devrons faire est de modifier le fichier cargo.toml dans notre dossier qui est automatiquement créé lorsque cargo a initialement créé le dossier. Nous allons implémenter un système d'interface utilisateur simple pour notre application (pour la rendre un peu plus esthétique). Pour cela, nous devrons modifier certaines dépendances. Notre fichier cargo.toml devrait maintenant ressembler à ceci :
(package)
name = "recipe_manager"
version = "0.1.0"
edition = "2021"(dependencies)
serde = { version = "1.0", features = ("derive") }
serde_json = "1.0"
iced = "0.8"
Il y a trois dépendances dans notre projet, mais deux d'entre elles sont liées. Serde est une méthode de sérialisation des données, et comme nos recettes seront d'un type de données unique, nous aurons besoin de serde pour les sauvegarder et les charger. Iced est un simple gestionnaire d'interface graphique qui fonctionne sur plusieurs systèmes d'exploitation. Nous l'utilisons car il est facile à mettre en œuvre et fonctionne avec presque tous les systèmes d'exploitation. Maintenant que nous avons terminé la configuration, nous pouvons passer au vrai plaisir : coder notre application.
Création du script de recette
La première chose que nous devrons créer est le script de recette qui stockera nos données. Dans VS Code, accédez au fichier recette.rs et ouvrez-le. Le fichier doit apparaître vide dans le volet de gauche. À partir de là, nous écrirons ce code :
use serde::{Serialize, Deserialize};
pub struct Recipe {
pub id: u32,
pub name: String,
pub ingredients: Vec<String>,
pub instructions: Vec<String>,
pub servings: u32,
}
impl Recipe {
pub fn new(id: u32, name: String, ingredients: Vec<String>, instructions: Vec<String>, servings: u32) -> Self {
Recipe {
id,
name,
ingredients,
instructions,
servings,
}
}
}
Ce code nous permet de créer une structure publique pour nos recettes, qui comprend des variables pour stocker la quantité de portion, les instructions, les ingrédients, le nom et un identifiant unique auquel se référer. Nous disposons également d'une fonction constructeur pour nous aider à créer de nouvelles instances de recettes une fois que nous avons obtenu les informations à mettre dans les variables. Maintenant que nous disposons d’une structure de recette, nous pouvons commencer à créer le gestionnaire d’applications.
Construire le gestionnaire d'applications
La structure des recettes nous permet de sauvegarder nos recettes, mais nous avons besoin de quelque chose qui gère la sauvegarde, le chargement et la mise à jour des recettes. Lorsque nous avons créé un outil de suivi des dépenses en Python, nous avons implémenté la sauvegarde et le chargement, mais dans Rust, ce processus est un peu différent. Voici à quoi devrait ressembler notre gestionnaire d'applications (stocké dans manager.rs dans notre dossier de projet) :
Nous allons d'abord commencer par importer notre structure de recette que nous avons codée précédemment et la bibliothèque fs pour gérer les entrées et sorties de fichiers (lecture et sauvegarde de fichiers). Juste en dessous, nous définirons notre gestionnaire de recettes et l'instance. Nous pouvons considérer le gestionnaire de recettes comme un conteneur qui contient toutes nos recettes et les organise.
Après c'est le add_recipe fonction qui :
- Prend les détails de la recette comme paramètres.
- Crée un nouveau
Recipeavec le courantnext_id. - Ajoute la recette au
recipesvecteur. - Incréments
next_idpour la prochaine recette. - Renvoie l'ID de la recette nouvellement ajoutée.
Le get_all_recipes La fonction renvoie une référence à la liste complète des recettes. Le get_recipe La fonction recherche la liste des recettes et en renvoie une en fonction de l'ID qu'elle prend en entrée. Le update_recipe La fonction recherche une recette et nous permet de mettre à jour les détails de cette recette et enregistre la nouvelle copie. Le delete_recipe la fonction supprime la recette de la liste.
En plus de ces fonctions, nous disposons de fonctions d'exploitation de fichiers pour sauvegarder et charger la liste des recettes. Cela nous donne une base décente pour notre programme, mais rendons-le un peu plus joli.
Implémentation de l'interface graphique
Une interface utilisateur de base en ligne de commande pourrait fonctionner pour ce programme, mais ce sera une interface très ennuyeuse. Pimentons le tout en écrivant du code pour notre fichier ui.rs :
Une fois que nous avons importé iced dans notre fichier, nous pouvons concevoir l’interface utilisateur correspondante. L’interface utilisateur conduit à une expérience utilisateur différente et, bien qu’il s’agisse de deux choses distinctes, elles sont liées. Le code contenu dans notre fichier d'interface utilisateur créera une expérience agréable pour nos utilisateurs et les encouragera à utiliser notre programme pour le stockage de leurs recettes. Cela nous facilite également la vie puisque naviguer dans une interface utilisateur est cent fois plus simple que dans une fenêtre de terminal. Chaque application est différente, donc expérimenter la disposition de l'interface utilisateur est quelque chose que vous devriez faire jusqu'à ce que vous en trouviez une qui vous plaise. Cette mise en page fonctionne pour moi, nous allons donc voir si notre code s'exécute.
Configuration de main.rs et exécution de notre code
Dans le dossier « src » de notre dossier principal Recipe_manager, nous avons un fichier main.rs. nous allons écraser le code existant avec ceci :
mod recipe;
mod manager;
mod ui;fn main() -> iced::Result {
gui::run()
}
Notre interprète commencera immédiatement à se plaindre de ne pas trouver de recette, de gestionnaire ou d'interface utilisateur, mais il existe une solution simple à ce problème. Sélectionnez simplement tous ces fichiers dans le dossier principal et faites-les glisser et déposez-les dans le dossier src. Le fichier main.rs ne verra aucun fichier situé en dehors de son propre dossier, il s'agit donc d'une solution simple à ce problème. Une fois ce problème résolu, nous pouvons essayer d’exécuter notre code et voir s’il fonctionne.
Ouvrez le dossier de votre projet dans un terminal et tapez :
cargo run
Vous devriez voir Rust construire votre projet. Si vous rencontrez des erreurs, assurez-vous que votre Rust est à jour en ouvrant une fenêtre de terminal et en tapant :
rustup update
Attendez ensuite la fin du téléchargement de la mise à jour et exécutez à nouveau le programme. Notre gestionnaire de recettes final ressemble à ceci :
Comme toujours, vous pouvez obtenir le code complet de ce projet sur mon GitHub. Ce projet est assez simple, mais vous pouvez faire certaines choses vous-même pour le rendre meilleur. Vous pouvez potentiellement développer un gestionnaire de recettes robuste à partir de cela. A la fin de la création de ce gestionnaire de recettes, vous devriez avoir une bonne idée de ce dont Rust est capable.
