En Rust, el módulo std::os proporciona una abstracción sobre la funcionalidad del sistema operativo. Nos permite interactuar con el sistema operativo subyacente para trabajar con las variables de entorno, las operaciones del sistema de archivos, la gestión de procesos y más.
En este ejemplo, cubriremos algunas operaciones fundamentales que puede realizar en Unix usando el módulo Rust std::os.
Es bueno recordar que este es un módulo extenso y contiene muchos tipos y funciones para varias operaciones relacionadas con Unix. Por lo tanto, tenga en cuenta la documentación de referencia sobre los procesos correspondientes.
Sistema operativo Rust en Linux
En Linux, podemos acceder a las funciones y tipos específicos de Unix que proporciona el módulo std::os::unix, un submódulo del módulo std::os en Rust.
Este módulo es parte de la biblioteca estándar de Rust y, por lo tanto, no requiere que instale ninguna dependencia o caja externa.
Veamos algunas API y operaciones básicas que podemos llevar a cabo en un sistema Linux desde este módulo.
Acceso a las variables de entorno
Podemos acceder a las variables de entorno usando el módulo std::env. Por ejemplo, std::env::var(“PATH”) recupera el valor de la variable de entorno PATH.
Considere el siguiente programa de ejemplo:
uso std::env;utilice std::ffi::OsString;
mano fn ( ) {
// Acceder a una variable de entorno específica
si dejar De acuerdo ( valor ) = entorno::var ( 'WAYLAND_DISPLAY' ) {
imprimir ! ( 'WAYLAND_DISPLAY={}' , valor ) ;
}
// Iterar sobre todas las variables de entorno
para ( valor clave ) en env::wars_es ( ) {
dejar key_string = key.to_string_lossy ( ) ;
dejar value_string = value.to_string_lossy ( ) ;
imprimir ! ( '{}: {}' , cadena_clave, cadena_valor ) ;
}
// Acceder a una variable de entorno específica como un ` OsString `
si dejar Alguno ( valor ) = entorno::var_us ( 'TIPO DE HOST' ) {
// Convertir ` OsString ` a un ` Cadena ` si necesario
si dejar Alguno ( cadena_valor ) = valor.to_str ( ) {
imprimir ! ( 'TIPO DE HOST={}' , cadena_valor ) ;
}
}
}
En el ejemplo dado, comenzamos importando los módulos necesarios. En este caso, estamos interesados en std::env y std::ff::OsString.
Para acceder a una variable de entorno específica, podemos usar la función env::var y pasar el nombre del valor que deseamos obtener. En este caso, obtenemos el valor de la variable WAYLAND_DISPLAY.
La función devuelve el valor de la variable como un tipo de resultado.
También podemos iterar sobre todas las variables de entorno usando la función env::vars_os. Esto devuelve un iterador con los pares clave-valor de las variables de entorno. Es bueno tener en cuenta que los valores se devuelven como un tipo OsString. Luego podemos convertirlos en valores de cadena usando la función to_string_lossy.
También podemos acceder a las variables de entorno específicas utilizando la función env::var_os. Esto debería devolver un tipo
La salida resultante es la siguiente:
WAYLAND_DISPLAY =wayland- 0TIPO DE HOST =x86_64
Operaciones de FS utilizando el módulo OS
Como puede adivinar, el módulo del sistema operativo proporciona varias funciones y métodos para realizar las operaciones relacionadas con el sistema de archivos.
Tome el siguiente programa que demuestra las diversas operaciones que podemos realizar usando el módulo std::os en Linux:
usar std::fs;mano fn ( ) {
// Leer un archivo
si dejar De acuerdo ( contenido ) = fs::leer_en_cadena ( '/home/debian/.bashrc' ) {
imprimir ! ( 'bashrc: {}' , contenido ) ;
}
// Crear un nuevo directorio
si dejar Errar ( errar ) = fs::create_dir ( '/home/debian/nuevo_dir' ) {
eprintln ! ( 'Error al crear el directorio: {}' , errar ) ;
}
// Quitar un archivo
si dejar Errar ( errar ) = fs::eliminar_archivo ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Error al eliminar el archivo: {}' , errar ) ;
}
}
En el ejemplo dado, demostramos cómo podemos leer el contenido de un archivo usando el método fs::read_to_string(). El método toma la ruta al archivo de destino y devuelve el contenido del archivo como una cadena.
También podemos crear un nuevo directorio usando la función fs::create_dir() y pasando la ruta al directorio de destino como parámetro.
Finalmente, podemos eliminar un archivo específico usando la función fs::remove_file() y pasar el archivo de destino como parámetro.
NOTA: Los ejemplos proporcionados son algunos ejemplos básicos sobre cómo realizar las operaciones del sistema de archivos en Linux utilizando el módulo std::fs. Rust proporciona una colección completa de métodos y funciones que se muestran aquí. Consulte la documentación para obtener más información.
Gestión de procesos utilizando el módulo OS
Como puede adivinar, el módulo del sistema operativo proporciona submódulos y funciones para trabajar con procesos en el sistema.
Tome el siguiente código de ejemplo:
usar std::proceso:: { Dominio, salida } ;mano fn ( ) {
// ejecutar el ls dominio
dejar salida = Comando::nuevo ( 'ls' )
.arg ( '-la' )
.producción ( )
.esperar ( 'Error al ejecutar el comando' ) ;
si salida.estado.éxito ( ) {
dejar salida estándar = Cadena::from_utf8_lossy ( & salida.stdout ) ;
imprimir ! ( 'Salida de comando: \norte {}' , salida estándar ) ;
} demás {
dejar stderr = Cadena::from_utf8_lossy ( & salida.stderr ) ;
eprintln ! ( 'Error de comando: \norte {}' , estándar ) ;
salida ( 1 ) ;
}
}
En el ejemplo dado, comenzamos importando los módulos requeridos. En este caso, necesitamos los métodos 'comando' y 'salir' del submódulo std::process.
Luego usamos la función Command::new() para ejecutar el comando 'ls' y pasar los argumentos al comando.
Si tiene éxito, el comando debe devolver la lista de directorios para el directorio de trabajo actual de la siguiente manera:
Conclusión
Exploramos cómo usar las diversas funciones y métodos que proporciona el módulo y los submódulos std::os para realizar múltiples operaciones en sistemas Linux y similares a Unix. Recuerde que el módulo std::os es un módulo extenso que contiene una colección más amplia de funciones que las que se muestran en este tutorial.