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: Esses 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: Esses 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:

!/ lixeira / bash

enquanto getopts 'A:B:C:D:' detalhes; Faz

caso ' $detalhes ' dentro

UMA )

eco 'Nome do cidadão é $OPTARG ' ;;

B )

eco 'A identidade do cidadão é $OPTARG ' ;;

C )

eco 'O local de nascimento é $OPTARG ' ;;

D )

eco 'Ocupação é $OPTARG ' ;;

* )

saída 1 ;;

esac

feito

mudança ' $(($OPÇÃO -1) )'

E se [ ! -Com $ 1 ] ; então

eco 'Estado civil $ 1'

senão

eco 'Sem Entradas'

saída 1

ser

E se [ ! -Com $ 2 ] ; então

eco 'Membros da família $ 2'

ser

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 flags. 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

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

Faz

caso ' ${flag_info} ' dentro
< olá >
< este > j ) nome do cidadão = ${OPTARG} ;; este >
< este > k ) Identificação do cidadão = ${OPTARG} ;; este >
< este > eu ) Lugar, colocar = ${OPTARG} ;; este >
< este > m ) era = ${OPTARG} ;; este >
< este > n ) ocupação = ${OPTARG} ;; este >
olá >
esac

feito

eco 'Aqui estão os detalhes inseridos:'

eco 'Nome do Cidadão: $citizenname ' ;

eco 'Identificação do cidadão: $cidadão ' ;

eco 'Lugar: $lugar ' ;

eco 'Era: $ idade ' ;

eco 'Ocupação: $ocupação ' ;

O script dará o seguinte resultado no terminal:

. /< roteiro > .sh -j Danny -k 476 -eu Toronto -m 25 -n Autor

Usando [e-mail protegido] Com loops

O ' [e-mail protegido] A variável nada mais é do que a matriz de todos os argumentos de entrada. Podemos passar qualquer número de entradas usando o “ [e-mail protegido] ' variável. Você pode usar essa variável como um loop para percorrer os argumentos. O ' [e-mail protegido] ” a variável é útil então; você não sabe o tamanho da entrada e não pode aceitar os argumentos posicionais. Assim, você pode usar o “ [e-mail protegido] ” em vez de definir a função getopt repetidas vezes. Aqui está um exemplo de uso de loops e [e-mail protegido] juntos em um script:

#!/bin/bash

num = ( “$ @ ” )

E se [ $# -gt 1 ]

então

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

eco 'A soma de todos os números é: $adicionar '

subtração =$ ( ( ${num[0]} - ${num[1]} - ${num[2]} ) )

eco 'A subtração dos números é: $subtração '

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

eco 'A multiplicação dos números é: $multiplicar '

divisão1 =$ ( ( ${num[0]} / ${num[1]} ) )

eco 'Divisão do ${num[0]} e ${num[1]} é: $divisão1 '

divisão2 =$ ( ( ${num[1]} / ${num[2]} ) )

eco 'Divisão de ${num[1]} e ${num[2]} é: $divisão2 '

divisão3 =$ ( ( ${num[0]} / ${num[2]} ) )

eco 'Divisão de ${num[0]} e ${num[2]} é: $divisão2 '

ser

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

eco 'Aqui estão os detalhes inseridos'

eco 'nome $1'

eco 'cidade $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?