Dans Rust, le module std::os fournit une abstraction des fonctionnalités du système d'exploitation. Il nous permet d'interagir avec le système d'exploitation sous-jacent pour travailler avec les variables d'environnement, les opérations du système de fichiers, la gestion des processus, etc.
Dans cet exemple, nous couvrirons certaines opérations fondamentales que vous pouvez effectuer sous Unix à l'aide du module Rust std::os.
Il est bon de se rappeler qu'il s'agit d'un module complet et qu'il contient de nombreux types et fonctions pour diverses opérations liées à Unix. Par conséquent, veuillez consulter la documentation à titre de référence sur les processus correspondants.
Rust OS sous Linux
Sous Linux, nous pouvons accéder aux fonctions et types spécifiques à Unix fournis par le module std :: os :: unix, un sous-module du module std :: os dans Rust.
Ce module fait partie de la bibliothèque standard Rust et ne nécessite donc pas l'installation d'un crate ou de dépendances externes.
Couvrons quelques API et opérations de base que nous pouvons effectuer sur un système Linux à partir de ce module.
Accéder aux variables d'environnement
Nous pouvons accéder aux variables d'environnement à l'aide du module std :: env. Par exemple, std::env::var('PATH') récupère la valeur de la variable d'environnement PATH.
Considérez l'exemple de programme suivant :
utilisez std :: env;utilisez std::ffi::OsString ;
fn main ( ) {
// Accéder à une variable d'environnement spécifique
si laisser D'accord ( valeur ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , valeur ) ;
}
// Itérer sur toutes les variables d'environnement
pour ( valeur clé ) dans env ::wars_us ( ) {
laisser key_string = key.to_string_lossy ( ) ;
laisser value_string = value.to_string_lossy ( ) ;
println ! ( '{} :{}' , chaîne_clé, chaîne_valeur ) ;
}
// Accéder à une variable d'environnement spécifique comme un ` OsString `
si laisser Quelques ( valeur ) = env::var_us ( 'TYPE D'HÔTE' ) {
// Convertir ` OsString ` à un ` Chaîne ` si nécessaire
si laisser Quelques ( value_str ) = value.to_str ( ) {
println ! ( 'TYPEHÔTE={}' , chaîne_valeur ) ;
}
}
}
Dans l'exemple donné, nous commençons par importer les modules nécessaires. Dans ce cas, nous nous intéressons au std::env et au std::ff::OsString.
Pour accéder à une variable d'environnement spécifique, nous pouvons utiliser la fonction env :: var et transmettre le nom de la valeur que nous souhaitons récupérer. Dans ce cas, nous obtenons la valeur de la variable WAYLAND_DISPLAY.
La fonction renvoie la valeur de la variable en tant que type de résultat.
Nous pouvons également parcourir toutes les variables d'environnement à l'aide de la fonction env::vars_os. Cela renvoie un itérateur avec les paires clé-valeur des variables d'environnement. Il est bon de noter que les valeurs sont renvoyées sous la forme d'un type OsString. Nous pouvons ensuite les convertir en valeurs de chaîne à l'aide de la fonction to_string_lossy.
Nous pouvons également accéder aux variables d'environnement spécifiques à l'aide de la fonction env::var_os. Cela devrait renvoyer un type
La sortie résultante est la suivante :
WAYLAND_DISPLAY =wayland- 0TYPE D'HÔTE =x86_64
Opérations FS à l'aide du module OS
Comme vous pouvez le deviner, le module OS fournit diverses fonctions et méthodes pour effectuer les opérations liées au système de fichiers.
Prenez le programme suivant qui illustre les différentes opérations que nous pouvons effectuer à l'aide du module std :: os sous Linux :
utilisez std :: fs;fn main ( ) {
// Lire un déposer
si laisser D'accord ( Contenu ) = fs :: read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc : {}' , Contenu ) ;
}
// Créer un nouveau répertoire
si laisser Se tromper ( se tromper ) = fs::create_dir ( '/home/debian/nouveau_répertoire' ) {
eprintln ! ( 'Échec de la création du répertoire : {}' , erreur ) ;
}
// Supprimer un déposer
si laisser Se tromper ( se tromper ) = fs :: remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Échec de la suppression du fichier : {}' , erreur ) ;
}
}
Dans l'exemple donné, nous montrons comment lire le contenu d'un fichier en utilisant la méthode fs::read_to_string(). La méthode prend le chemin d'accès au fichier cible et renvoie le contenu du fichier sous forme de chaîne.
Nous pouvons également créer un nouveau répertoire en utilisant la fonction fs::create_dir() et en passant le chemin vers le répertoire cible comme paramètre.
Enfin, nous pouvons supprimer un fichier spécifique en utilisant la fonction fs :: remove_file() et passer le fichier cible en paramètre.
NOTE: Les exemples fournis sont des exemples de base sur la façon d'effectuer les opérations de système de fichiers sous Linux à l'aide du module std::fs. Rust fournit une collection complète de méthodes et de fonctions qui sont démontrées ici. Reportez-vous à la documentation pour en savoir plus.
Gestion des processus à l'aide du module OS
Comme vous pouvez le deviner, le module OS fournit des sous-modules et des fonctionnalités pour travailler avec les processus du système.
Prenons l'exemple de code suivant :
utiliser std :: processus :: { Commande, sortie } ;fn main ( ) {
// exécuter le ls commande
laisser sortie = Commande :: nouveau ( 'ls' )
.arg ( '-la' )
.sortir ( )
.attendre ( 'Échec de l'exécution de la commande' ) ;
si sortie.état.succès ( ) {
laisser stdout = Chaîne :: from_utf8_lossy ( & sortie.stdout ) ;
println ! ( 'Sortie de la commande : \n {}' , sortie standard ) ;
} autre {
laisser stderr = Chaîne :: from_utf8_lossy ( & sortie.stderr ) ;
eprintln ! ( 'Échec de la commande : \n {}' , stderr ) ;
sortie ( 1 ) ;
}
}
Dans l'exemple donné, nous commençons par importer les modules requis. Dans ce cas, nous avons besoin des méthodes « command » et « exit » du sous-module std :: process.
Nous utilisons ensuite la fonction Command::new() pour exécuter la commande 'ls' et transmettre les arguments à la commande.
En cas de succès, la commande doit renvoyer la liste des répertoires pour le répertoire de travail actuel comme suit :
Conclusion
Nous avons exploré comment utiliser les différentes fonctions et méthodes fournies par le module et les sous-modules std::os pour effectuer plusieurs opérations dans des systèmes Linux et de type Unix. N'oubliez pas que le module std::os est un module complet qui contient une collection de fonctionnalités plus large que celles présentées dans ce didacticiel.