In Rust, il modulo std::os fornisce un'astrazione sulla funzionalità del sistema operativo. Ci consente di interagire con il sistema operativo sottostante per lavorare con le variabili di ambiente, le operazioni del file system, la gestione dei processi e altro ancora.
In questo esempio, tratteremo alcune operazioni fondamentali che puoi eseguire su Unix usando il modulo Rust std::os.
È bene ricordare che questo è un modulo esteso e contiene molti tipi e funzioni per varie operazioni legate a Unix. Pertanto, si prega di prendere in considerazione la documentazione di riferimento sui processi corrispondenti.
Sistema operativo ruggine in Linux
In Linux, possiamo accedere alle funzioni e ai tipi specifici di Unix forniti dal modulo std::os::unix, un sottomodulo del modulo std::os in Rust.
Questo modulo fa parte della libreria standard di Rust e quindi non richiede l'installazione di alcun crate o dipendenza esterna.
Copriamo alcune API e operazioni di base che possiamo eseguire su un sistema Linux da questo modulo.
Accesso alle variabili d'ambiente
Possiamo accedere alle variabili d'ambiente usando il modulo std::env. Ad esempio, std::env::var(“PATH”) recupera il valore della variabile di ambiente PATH.
Si consideri il seguente programma di esempio:
usa std::env;usa std::ffi::OsString;
in mano ( ) {
// Accedi a una variabile di ambiente specifica
Se permettere OK ( valore ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , valore ) ;
}
// Iterare su tutte le variabili di ambiente
per ( chiave, valore ) In env::wars_us ( ) {
permettere key_string = key.to_string_lossy ( ) ;
permettere value_string = value.to_string_lossy ( ) ;
println ! ( '{}:{}' , stringa_chiave, stringa_valore ) ;
}
// Accedi a una variabile di ambiente specifica COME UN ` OsString `
Se permettere Alcuni ( valore ) = env::var_us ( 'TIPO HOST' ) {
// Convertire ` OsString ` ad un ` Corda ` Se necessario
Se permettere Alcuni ( valore_str ) = valore.to_str ( ) {
println ! ( 'HOSTTYPE={}' , valore_str ) ;
}
}
}
Nell'esempio dato, iniziamo importando i moduli necessari. In questo caso, siamo interessati a std::env e std::ff::OsString.
Per accedere a una variabile d'ambiente specifica, possiamo utilizzare la funzione env::var e passare il nome del valore che desideriamo recuperare. In questo caso, otteniamo il valore della variabile WAYLAND_DISPLAY.
La funzione restituisce il valore della variabile come tipo di risultato.
Possiamo anche iterare su tutte le variabili d'ambiente usando la funzione env::vars_os. Questo restituisce un iteratore con le coppie chiave-valore delle variabili di ambiente. È bene notare che i valori vengono restituiti come tipo OsString. Possiamo quindi convertirli in valori stringa utilizzando la funzione to_string_lossy.
Possiamo anche accedere alle variabili d'ambiente specifiche usando la funzione env::var_os. Questo dovrebbe restituire un tipo
L'output risultante è il seguente:
WAYLAND_DISPLAY =via di passaggio- 0TIPO HOST =x86_64
Operazioni FS utilizzando il modulo OS
Come puoi intuire, il modulo OS fornisce varie funzioni e metodi per eseguire le operazioni relative al filesystem.
Prendi il seguente programma che mostra le varie operazioni che possiamo eseguire usando il modulo std::os in Linux:
usa std::fs;in mano ( ) {
// Leggi un file
Se permettere OK ( Contenuti ) = fs::read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , Contenuti ) ;
}
// Crea una nuova directory
Se permettere Err ( errare ) = fs::create_dir ( '/home/debian/nuova_dir' ) {
eprintln ! ( 'Impossibile creare la directory: {}' , errare ) ;
}
// Rimuovi un file
Se permettere Err ( errare ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Impossibile rimuovere il file: {}' , errare ) ;
}
}
Nell'esempio dato, dimostriamo come possiamo leggere il contenuto di un file usando il metodo fs::read_to_string(). Il metodo prende il percorso del file di destinazione e restituisce il contenuto del file come stringa.
Possiamo anche creare una nuova directory usando la funzione fs::create_dir() e passando il percorso alla directory di destinazione come parametro.
Infine, possiamo rimuovere un file specifico utilizzando la funzione fs::remove_file() e passare il file di destinazione come parametro.
NOTA: Gli esempi forniti sono alcuni esempi di base su come eseguire le operazioni del filesystem su Linux utilizzando il modulo std::fs. Rust fornisce una raccolta completa di metodi e funzioni che vengono dimostrati qui. Fare riferimento alla documentazione per saperne di più.
Gestione dei processi tramite il modulo OS
Come puoi intuire, il modulo OS fornisce sottomoduli e funzionalità per lavorare con i processi nel sistema.
Prendi il seguente codice di esempio:
usa std::process:: { Comando, Uscita } ;in mano ( ) {
// corri il ls comando
permettere output = Comando::new ( 'l' )
.arg ( '-IL' )
.produzione ( )
.aspettarsi ( 'Impossibile eseguire il comando' ) ;
Se output.status.success ( ) {
permettere stdout = String::from_utf8_lossy ( & output.stdout ) ;
println ! ( 'Uscita comando: \N {}' , standardout ) ;
} altro {
permettere stderr = String::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'Comando non riuscito: \N {}' , stderr ) ;
Uscita ( 1 ) ;
}
}
Nell'esempio fornito, iniziamo importando i moduli richiesti. In questo caso, abbiamo bisogno dei metodi 'command' e 'exit' dal sottomodulo std::process.
Quindi usiamo la funzione Command::new() per eseguire il comando 'ls' e passare gli argomenti al comando.
In caso di successo, il comando dovrebbe restituire l'elenco delle directory per la directory di lavoro corrente come segue:
Conclusione
Abbiamo esplorato come utilizzare le varie funzioni e metodi forniti dal modulo e dai sottomoduli std::os per eseguire più operazioni in sistemi Linux e simili a Unix. Ricorda che il modulo std::os è un modulo esteso che contiene una raccolta di funzionalità più ampia rispetto a quelle mostrate in questo tutorial.