Argumentos de línea de comandos de óxido

Los argumentos de línea de comandos se refieren a un conjunto de valores o especificadores que se pasan al nombre de un programa terminal. Estos argumentos pueden, por lo tanto, modificar el comportamiento del programa como se define en el código fuente.

Por ejemplo, puede pasar el directorio que desea enumerar al comando ls. Por lo tanto, el camino hacia el directorio se conoce como argumento para el comando ls.

Este artículo revisará los fundamentos de aceptar y analizar argumentos de la línea de comandos en el lenguaje de programación de óxido utilizando el módulo ENV de la biblioteca estándar.

Configuración e importaciones

El primer paso es crear un directorio para almacenar nuestro código fuente. Para simplificar, generemos un paquete de óxido usando carga como:

$ Cargo New Rust_arguments

Cambie el nombre de su proyecto a cualquier nombre que mejor le.

A continuación, navegue por el directorio de origen y abra el principal.Archivo RS con su editor de texto favorito.

$ CD Rust_arguments/Src && Vim Main.RS

El segundo paso es importar los módulos requeridos. Usaremos el módulo Env de la biblioteca estándar para analizar los argumentos de la línea de comandos para este artículo.

El módulo ENV proporciona una función para trabajar con variables de entorno, argumentos, etc. Para usarlo, importarlo usando como:

usar std :: env;

Vector de argumento

Dentro de la función principal, necesitamos crear un vector de cadenas que mantenga los argumentos que pasaremos al programa.

Podemos hacer esto agregando la siguiente línea:

Let ARGS: VEC = env :: args ().recolectar();

El código anterior utiliza el método de recopilación para iterar sobre el argumento pasado a los argumentos y agregarlos al vector. El vector es de tipos de cadenas anotadas por el VEC en nuestro caso. Esto se debe a que el óxido no puede inferir el tipo de colección de vectores.

Imprimir argumentos

Ahora que podemos aceptar argumentos de comando y guiarlos en un vector, intentemos imprimirlos. Podemos hacer esto con la función ITER, como se muestra a continuación:

usar std :: env;
fn main ()
Let ARGS: VEC = env :: args ().recolectar();
para arg en args.iter ()
println!("", arg);

La función iterer se iterará sobre cada argumento pasado al programa e imprimirá. Si ejecutamos el código anterior, deberíamos ver una salida como:

El programa devuelve el nombre del ejecutable. El óxido tratará el nombre del ejecutable como el primer argumento. Por lo tanto, el argumento en el índice 0 en el vector de argumento es la ruta al nombre del programa.

Esta es una característica común en otros lenguajes de programación, incluidos C, Python, GO, etc.

Si proporcionamos otros argumentos después del nombre del programa, Rust los agregará al índice 1, 2, 3 ... al vector de argumentos.

Por ejemplo:

Cargo Run Argumento1 Argumento2 Argumento3 ... Argumenton

Tenga en cuenta que el ejemplo anterior pasa 5 argumentos al programa. El resultado es como se muestra:

Target \ Debug \ Rust_cmd_args.exe
argumento1
argumento2
argumento3
…
argumento

Como puede ver, el programa imprime todos los argumentos aprobados.

Acceder y guardar argumentos

Hasta ahora, solo hemos imprimido los argumentos del programa. Aunque ilustra cómo funcionan los vectores de argumentos, realmente no hace mucho.

Podemos acceder y guardar cada argumento a una variable para expandir nuestro programa.

Para acceder a un argumento, podemos usar el índice como:

usar std :: env;
fn main ()
Let ARGS: VEC = env :: args ().recolectar();
println!("", args [1]);

En el ejemplo anterior, accedemos al primer argumento usando el índice 1. El resultado es como se muestra:

Cargo Run HI!

Podemos guardar el argumento en una variable como:

usar std :: env;
fn main ()
Let ARGS: VEC = env :: args ().recolectar();
Let Greet = & args [1];
Si saludo == "HI"
println!("Hola de nuevo!");
demás
println!("Solo aceptamos saludos!")

En el programa anterior, aceptamos guardar el primer argumento y guardarlo en una variable. Luego usamos su valor en un bloque if ... de lo contrario para realizar una acción.

Podemos ejecutar el código anterior como:

$ Cargo Run HI

El programa debería devolver “Hola!" como:

Si pasamos otro argumento que no es igual a "Hola", ejecutamos el bloque de Else como:

$ Cargo Run Bye

Conclusión

Fantástico! Tenemos un programa que puede aceptar, analizar, guardar y argumentos con eso. Sigue practicando para aprender más.