Como lidar com argumentos da linha de comando em Bash?

No Linux, usamos argumentos de linha de comando como entrada para o script Bash. Bash pode levar esses argumentos da linha de comando sequencialmente e analisá-los como uma opção. Esses argumentos permitem que você afete as ações e a saída do script dinamicamente.

Você pode configurar esses argumentos de maneira diferente para influenciar a entrada e saída. É por isso que o manuseio da linha de comando args em Bash é essencial, mas muitos novos usuários precisam aprender a fazer isso. Então, neste guia, explicaremos maneiras diferentes de lidar com argumentos da linha de comando em Bash.

Como lidar com argumentos da linha de comando em Bash?

Existem várias maneiras de lidar com a linha de comando args em bash, então vamos dar uma olhada neles para obter informações breves:

A função GOTOpt

A função GOTOpt é útil, pois fornece as opções e sintaxe para definir e analisar argumentos em Bash. É uma função interna do Linux que você pode usar ao criar um arquivo de banco de dados ou relatório em um formato específico com base nos argumentos. A função GOTOpt ajuda a analisar os argumentos curtos da linha de comando, porque existem dois tipos de argumentos:

• Argumentos curtos: Estes são os argumentos de caracteres únicos seguidos por um hífen. Por exemplo, -a, -l, -h, etc., são alguns exemplos de argumentos únicos.

• Longos argumentos: Estes são os argumentos de vários caracteres seguidos por um hifen duplo. Existem vários exemplos de longos argumentos, como -Al, -list, -Help, etc.

Vamos dar um exemplo em que lidaremos com os argumentos da linha de comando usando o utilitário GOTOPT. Criamos um script de bash chamado “Getopt.sh ”que contém as seguintes informações:

!/BIN/BASH
enquanto getopts 'A: B: C: D:' Detalhes; fazer
caso "$ detalhes" em
A)
eco "Nome do cidadão é $ optarg" ;;
B)
Echo "Citizen Id is $ optarg" ;;
C)
Echo "Birth Place é $ optarg" ;;
D)
eco "ocupação é $ optarg" ;;
*)
saída 1 ;;
ESAC
feito
turno "$ (($ optind -1))"
se [ ! -z $ 1]; então
eco "Estado civil $ 1"
outro
eco "sem entradas"
saída 1
fi
se [ ! -z $ 2]; então
eco "membros da família $ 2"
fi

Agora vamos executar o script com os argumentos necessários na entrada:

Como você pode ver na imagem acima, executamos o script apenas com as funções GETOpt e depois adicionamos argumentos normais para obter o resultado completo.

Usando sinalizadores

Bandeiras não passam de caracteres únicos precedidos por hífens (-). Quando passamos os argumentos usando a função GOTOPT, usamos sinalizadores. -a, -b, -c são alguns exemplos de bandeiras. Por exemplo, um script requer nome de um cidadão, identificação, local, idade e ocupação. Por isso, usamos bandeiras J, K, L, M, N, para definir o nome do cidadão, ID, lugar, idade e ocupação simultaneamente:

#!/BIN/BASH
Enquanto getopts j: k: l: m: n: flag_info
fazer
case "$ flag_info" em

1. j) cidadão = $ optarg ;;


2. k) Citizenid = $ optarg ;;


3. l) local = $ optarg ;;


4. m) idade = $ optarg ;;


5. n) ocupação = $ optarg ;;

ESAC
feito
eco "Aqui estão os detalhes inseridos:"
eco "Nome do cidadão: $ cidadão";
eco "cidadão id: $ cidadenid";
eco "Place: $ Place";
eco "idade: $ idade";
eco "ocupação: $ ocupação";

O script dará o seguinte resultado no terminal:

.//

Usando $@ com loops

A variável "$@" nada mais é do que a matriz de todos os argumentos de entrada. Podemos passar qualquer número de entradas usando a variável "$@". Você pode usar essa variável como um loop para iterar através dos argumentos. A variável "$@" é útil então; Você não conhece o tamanho da entrada e não pode aceitar os argumentos posicionais. Portanto, você pode usar o "$@" em vez de definir a função GOTOPT repetidamente. Aqui está um exemplo de uso de loops e $@ juntos em um script:

#!/BIN/BASH
num = ("$@")
Se [$# -GT 1]
então
add = $ (($ num [0]+$ num [1])))
eco "A adição de todos os números é: $ add"
subtração = $ (($ num [0]-$ num [1]-$ num [2])))
eco "A subtração dos números é: $ subtração"
Multiply = $ (($ num [0]*$ num [1]*$ num [2])))
eco "A multiplicação dos números é: $ multiplique"
divisão1 = $ (($ num [0]/$ num [1]))
eco "Divisão do $ num [0] e $ num [1] é: $ division1"
divisão2 = $ (($ num [1]/$ num [2])))
eco "Divisão de $ num [1] e $ num [2] é: $ division2"
divisão3 = $ (($ num [0]/$ num [2]))
eco "Divisão de $ num [0] e $ num [2] é: $ division2"
fi

O script acima executa diferentes cálculos aritméticos com base nos argumentos da linha de comando. Por exemplo, inserimos 50, 35 e 15 como entrada:

Usando parâmetros posicionais

Você pode acessar os parâmetros posicionais à medida que eles acessam US $ 1 primeiro, depois US $ 2 e assim por diante. Por exemplo, vamos criar um script que lê um nome como o primeiro argumento e depois uma cidade como o segundo. No entanto, se você passar pela cidade primeiro e depois o nome, então ela considera o nome como a cidade e vice -versa. Vamos dar um mergulho mais profundo no script a seguir para entender esse conceito:

#!/BIN/BASH
eco "Aqui estão os detalhes inseridos"
eco "Nome $ 1"
eco "Cidade $ 2"

Você precisa adicionar o nome e a cidade no momento da execução do script no terminal:

Empacotando

Isso é tudo o que você precisa saber sobre os métodos para lidar com argumentos da linha de comando em bash. Explicamos abordagens diferentes que você pode experimentar com os exemplos apropriados. Existem vários comandos se você quiser adicionar argumentos no script. Portanto, visite Linuxhint para saber mais sobre eles.