Como lidar com argumentos de linha de comando no Bash?

No Linux, usamos argumentos de linha de comando como entrada para o script bash. O Bash pode pegar esses argumentos de 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 forma diferente para influenciar a entrada e a saída. É por isso que lidar com argumentos de linha de comando no bash é essencial, mas muitos novos usuários precisam aprender como fazer isso. Portanto, neste guia, explicaremos diferentes maneiras de lidar com argumentos de linha de comando no bash.

Como lidar com argumentos de linha de comando no Bash?

Existem várias maneiras de lidar com argumentos de linha de comando no Bash, então vamos dar uma olhada nelas para obter informações breves:

A função getopt

A função getopt é útil, pois fornece as opções e a sintaxe para definir e analisar argumentos no 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 getopt ajuda a analisar os argumentos curtos da linha de comando porque há dois tipos de argumentos:

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

Argumentos longos: são os argumentos de vários caracteres seguidos por um hífen duplo. Existem vários exemplos de argumentos longos, como –all, –list, –help, etc.

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

!/bin/bash

while getopts 'A:B:C:D:' details; do

case "$details" in

A)

echo "Citizen Name is $OPTARG" ;;

B)

echo "Citizen ID is $OPTARG";;

C)

echo "Birth Place is $OPTARG";;

D)

echo "Occupation is $OPTARG";;

*)

exit 1;;

esac

done

shift "$(($OPTIND -1))"

if [ ! -z $1 ]; then

echo "Marital Status $1"

else

echo "No Entries"

exit 1

fi

if [ ! -z $2 ]; then

echo "Family Members $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 funções getopt e adicionamos argumentos normais para obter o resultado completo.

Usando sinalizadores

Os sinalizadores nada mais são do que caracteres únicos precedidos por hífens (-). Quando passamos os argumentos usando a função getopt, usamos sinalizadores. -a, -b, -c são alguns exemplos de sinalizadores. Por exemplo, um script exige o nome, documento de identidade, local, idade e ocupação de um cidadão. Assim, usamos sinalizadores j, k, l, m, n, para definir o nome do cidadão, RG, local, idade e ocupação simultaneamente:

#!/bin/bash

While getopts j:k:l:m:n: flag_info

do

case "${flag_info}" in
<ol>
<li>j) citizenname=${OPTARG};;</li>
<li>k) citizenid=${OPTARG};;</li>
<li>l) place=${OPTARG};;</li>
<li>m) age=${OPTARG};;</li>
<li>n) occupation=${OPTARG};;</li>
</ol>
esac

done

echo "Here are the entered details:"

echo "Citizen Name: $citizenname";

echo "Citizen ID: $citizenid";

echo "Place: $place";

echo "Age: $age";

echo "Occupation: $occupation";

O script dará o seguinte resultado no terminal:

./<script>.sh -j Danny -k 476 -l Toronto -m 25 -n Author

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 percorrer os argumentos. A variável “$@ ” é útil então; você não sabe o tamanho da entrada e não pode aceitar os argumentos posicionais. Portanto, você pode usar o “$@ ” em vez de definir a função getopt repetidas vezes. Aqui está um exemplo de uso de loops e $@ juntos em um script:

#!/bin/bash

num=(“$@”)

if [ $# -gt 1 ]

then

add=$((${num[0]}+${num[1]}))

echo "Addition of all numbers is: $add"

subtraction=$((${num[0]}-${num[1]}-${num[2]}))

echo "Subtraction of the numbers is: $subtraction"

multiply=$((${num[0]}*${num[1]}*${num[2]}))

echo "Multiplication of the numbers is: $multiply"

division1=$((${num[0]}/${num[1]}))

echo "Division of the ${num[0]} and ${num[1]} is: $division1"

division2=$((${num[1]}/${num[2]}))

echo "Division of ${num[1]} and ${num[2]} is: $division2"

division3=$((${num[0]}/${num[2]}))

echo "Division of ${num[0]} and ${num[2]} is: $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 conforme eles acessam $1 primeiro, depois $2 e assim por diante. Por exemplo, vamos criar um script que leia um nome como primeiro argumento e depois uma cidade como segundo. No entanto, se você passar primeiro a cidade e depois o nome, ele considera o nome como a cidade e vice-versa. Vamos nos aprofundar no script a seguir para entender esse conceito:

#!/bin/bash

echo "Here are the entered details"

echo "name $1"

echo "city $2"

Você precisa adicionar o nome e a cidade na hora de executar o script no terminal:

Empacotando

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

Como lidar com argumentos de linha de comando no Bash?