Argumentos da linha de comando de ferrugem

Argumentos da linha de comando se referem a um conjunto de valores ou especificadores que são passados ​​para o nome de um programa de terminal. Esses argumentos podem, portanto, modificar o comportamento do programa, conforme definido no código -fonte.

Por exemplo, você pode passar no diretório que deseja listar para o comando ls. Portanto, o caminho para o diretório é conhecido como o argumento do comando LS.

Este artigo analisará os fundamentos da aceitação e análise de argumentos da linha de comando na linguagem de programação da ferrugem usando o módulo Env da biblioteca padrão.

Configuração e importações

O primeiro passo é criar um diretório para armazenar nosso código -fonte. Para simplificar, vamos gerar um pacote de ferrugem usando carga como:

$ cargo new rust_arguments

Renomeie seu projeto para qualquer nome que você achar adequado.

Em seguida, navegue no diretório de origem e abra o principal.arquivo rs com seu editor de texto favorito.

$ cd rust_argudents/src && vim main.rs

O segundo passo é importar os módulos necessários. Usaremos o módulo Env da biblioteca padrão para analisar argumentos da linha de comando para este artigo.

O módulo Env fornece uma função para trabalhar com variáveis ​​de ambiente, argumentos, etc. Para usá -lo, importá -lo usando como:

use std :: Env;

Vetor de argumento

Dentro da função principal, precisamos criar um vetor de strings que mantenham os argumentos que passaremos para o programa.

Podemos fazer isso adicionando a seguinte linha:

Deixe Arg: VEC = Env :: args ().colecion ();

O código acima usa o método de coleta para iterar sobre o argumento passado para os argumentos e adicione -os ao vetor. O vetor é de strings de tipo como anotado pelo VEC em nosso caso. Isso ocorre porque a ferrugem não pode inferir o tipo de coleção de vetores.

Imprimir argumentos

Agora que podemos aceitar argumentos de comando e armazená -los em um vetor, vamos tentar imprimi -los. Podemos fazer isso com a função ITER, como mostrado abaixo:

use std :: Env;
fn main ()
Deixe Arg: VEC = Env :: args ().colecion ();
para arg em args.iter ()
println!("", arg);

A função ITER irá itera sobre cada argumento passado para o programa e imprimirá -lo. Se executarmos o código acima, devemos ver uma saída como:

O programa retorna o nome do executável. Rust tratará o nome do executável como o primeiro argumento. Portanto, o argumento no índice 0 no vetor de argumento é o caminho para o nome do programa.

Este é um recurso comum em outras linguagens de programação, incluindo C, Python, Go, etc.

Se fornecermos outros argumentos após o nome do programa, Rust os anexará ao índice 1, 2, 3… para o vetor de argumento.

Por exemplo:

Cargo Run argument1 argumento2 argumento3… argumenton

Observe que o exemplo acima passa 5 argumentos para o programa. O resultado é como mostrado:

Target \ debug \ rust_cmd_args.exe
argumento1
argumento2
argumento3
..
argumento

Como você pode ver, o programa imprime todos os argumentos aprovados.

Acessando e salvando argumentos

Até agora, apenas imprimimos os argumentos do programa. Embora ilustre como os vetores de argumento funcionam, ele realmente não faz muito.

Podemos acessar e salvar cada argumento em uma variável para expandir nosso programa.

Para acessar um argumento, podemos usar o índice como:

use std :: Env;
fn main ()
Deixe Arg: VEC = Env :: args ().colecion ();
println!("", args [1]);

No exemplo acima, acessamos o primeiro argumento usando o índice 1. O resultado é como mostrado:

Cargo Run Hi!

Podemos salvar o argumento em uma variável como:

use std :: Env;
fn main ()
Deixe Arg: VEC = Env :: args ().colecion ();
deixe cumprimentar = & args [1];
Se cumprimentar == "oi"
println!("Oi de novo!");
outro
println!("Nós apenas aceitamos saudações!")

No programa acima, aceitamos salvar o primeiro argumento e salvá -lo em uma variável. Em seguida, usamos seu valor em um bloco se ... else para executar uma ação.

Podemos executar o código acima como:

$ Cargo Run Hi

O programa deve devolver “oi de volta!" como:

Se passarmos outro argumento que não é igual a "oi", executamos o bloco else como:

$ Cargo Run Bye

Conclusão

Fantástico! Temos um programa que pode aceitar, analisar, salvar e argumentar com isso. Continue praticando para aprender mais.