Os desenvolvedores normalmente usam Bash para escrever scripts de shell invocando outros programas como comandos e adicionando recursos de linguagem Bash embutidos. Além disso, todo usuário de sistema Unix ou semelhante a Unix usa o Bash para se comunicar com o sistema operacional por meio de programas de terminal GUI. Um script de shell escrito em Bash contém vários elementos sintáticos. Parâmetros Bash são elementos sintáticos que frequentemente usamos em scripts de shell. Na linguagem Bash, um parâmetro é uma entidade que armazena um valor. Bash nos permite usar três tipos de parâmetros: variáveis, parâmetros posicionais e parâmetros especiais.

Uma variável tem um nome bem legível e vários atributos definidos por meio do declarebuilt-in. Algumas variáveis ​​são definidas com base nas variáveis ​​de ambiente de todo o sistema no sistema operacional. O interpretador Bash também define várias variáveis ​​de nível de shell. Além disso, podemos criar variáveis ​​globais ou locais dentro do shell script com base em nossos requisitos de desenvolvimento.

O interpretador Bash oferece alguns detalhes úteis durante a execução do script por meio de variáveis ​​de nível de shell. Em alguns cenários, podemos melhorar o desempenho do script usando variáveis ​​de shell sem invocar processos externos. Nesta história, explicarei várias variáveis ​​de shell úteis que você pode usar no Bash com exemplos práticos.

Verificando a versão do interpretador Bash com BASH_VERSINFO

A maioria dos programas CLI geralmente vem com o --versionsinalizador que imprime os detalhes da versão. O interpretador Bash também implementa esse sinalizador de linha de comando, para que os usuários do Bash possam usar o sinalizador específico para verificar os detalhes da versão. Suponha que você precise usar a sintaxe mais recente do Bash com base na versão do interpretador ou exibir uma mensagem de incompatibilidade para execuções mais antigas do interpretador Bash.

A BASH_VERSIONvariável shell normalmente retorna a string de versão completa, então devemos extrair as versões principais e secundárias primeiro. Em vez disso, você pode usar o BASH_VERSINFOarray (lançado no Bash 2.0) para acessar todas as partes da string da versão:

#!/bin/bash

if ((BASH_VERSINFO[0] < 5 ||
    (BASH_VERSINFO[0] == 5 && BASH_VERSINFO[1] < 1) )); then
    echo "This script requires Bash 5.1 or a higher version."
    exit 1
fi

#!/bin/bash

echo "You are using Bash ${BASH_VERSION%.*}"

Usando SECONDS para exibir o tempo de execução do script

O Bash se tornou a solução de automação nativa de todos os sistemas Unix ou semelhantes a Unix, então a maioria dos desenvolvedores o usa para automação baseada em shell scripts. Em alguns cenários, os scripts de shell são executados por um longo período. Por exemplo, você pode criar um script de shell para automatizar uma implantação de software que pode levar várias horas. A exibição do tempo decorrido sem dúvida melhora a facilidade de uso do script de shell nesses cenários. Além disso, pode ser necessário encerrar automaticamente um script de shell repetitivo e de execução longa com base em um valor de tempo limite.

A SECONDSvariável ajuda a medir os tempos de execução do script e apresentar soluções para os cenários acima. Observe o seguinte script que imprime o tempo de execução do comando:

#!/bin/bash

function start_timer() {
    SECONDS=0
}

function display_elapsed() {
    echo "Task executed in $SECONDS seconds"
}

# ---- Task 1 ----
start_timer
sleep 2
display_elapsed

# --- Task 2 ---
start_timer
sleep 3
display_elapsed

#!/bin/bash

TIMEOUT=10

while (( TIMEOUT > SECONDS )); do
    prog=$(bc <<< "scale=1; $SECONDS / $TIMEOUT * 100")
    echo "Processing... ${prog}%"
    sleep 2
done

echo "Stopped with ${TIMEOUT}-second timeout."

Usando PWD e OLDPWD

Todo usuário de sistema Unix ou semelhante a Unix conhece pwde cdcomanda. E se você precisar recuperar o diretório de trabalho atual ou o diretório de trabalho anterior em um script Bash? Esses comandos geralmente são iniciados por meio de processos separados (shells filhos), portanto, quando você usa esses comandos, eles interrompem a interpretação do script Bash para a criação de um novo processo. Você pode usar PWDe OLDPWDexportar variáveis ​​para obter com eficiência o diretório de trabalho atual e o diretório de trabalho anterior da seguinte forma:

#!/bin/bash

cd /home
echo "PWD -> $PWD"

cd ~- # Go to the previous directory
echo "PWD -> $PWD"
echo "OLDPWD -> $OLDPWD" # OLDPWD -> /home

PWD=/home

Usando BASH_COMMAND com Shell Traps

O BASH_COMMANDarmazena o valor do comando atualmente inserido. Se você imprimir o valor salvo desta variável com o echocomando, verá o mesmo echocomando inserido anteriormente. Então, como usar essa variável de maneira significativa? E, qual é o problema que BASH_COMMANDprecisa resolver?

Você pode usar BASH_COMMANDdentro de uma armadilha de shell. Em outras palavras, você pode obter o comando mais recente ao lidar com seus erros por meio do trapcomando. Um ótimo exemplo disso é exibir ou processar uma string de comando com falha com trap. Observe o trecho de código a seguir:

function __handle_cmd_err() {
    exit_code=$?
    echo "--------------"
    echo "ERR: '$BASH_COMMAND' command was terminated with error code $exit_code"

}

trap __handle_cmd_err ERR

Certifique-se de usar o $?parâmetro especial corretamente — se você repetir uma string e usar $?diretamente em outra echoinstrução, obterá o código de saída de echo— não o código de saída esperado do comando com falha.

O código de exemplo acima usa BASH_COMMANDcom ERRsinal, mas você também pode usar INTpara capturar interrupções de teclado e implementar instruções de limpeza.

Usando MACHTYPE, HOSTTYPE e OSTYPE como alternativa para Uname e Arch

Os administradores de sistema e engenheiros de DevOps costumam usar o unamecomando para recuperar detalhes da máquina em seus scripts de shell. O unamecomando permite encontrar os detalhes do kernel, da CPU e do sistema operacional. Por exemplo, você pode executar uname -mcom substituição de comando para atribuir a arquitetura da máquina a uma variável Bash. O archcomando também imprime a arquitetura do sistema.

O Bash oferece várias variáveis ​​de shell para obter os detalhes do sistema operacional e do hardware, para que você possa usá-los para obter informações do sistema sem chamar programas externos.

Você pode implementar verificações com a OSTYPEvariável shell para executar o código específico do sistema operacional ou detectar o nome do sistema operacional do usuário com uma instrução case:

#!/bin/bash


OS="Unknown"

case "$OSTYPE" in
    linux*)
        OS="Linux" ;;
    bsd*)
        OS="BSD" ;;
    # ---
    # -- TODO: Add other OS type checks...
    # ---
esac

echo $OS

#!/bin/bash

gcc main.c -o myprogram-${OSTYPE%%-*}_${HOSTTYPE}

Terminarei esta história com um fato bônus sobre shell scripting. Você sabe como verificar se um determinado comando é integrado, alias ou binário separado?

Usar type -a <command>:

Obrigado por ler.

Codificação de nível

Obrigado por fazer parte da nossa comunidade! Antes de você ir:

• Bata palmas para a história e siga o autor
• Veja mais conteúdo na publicação Level Up Coding
• Curso gratuito de entrevista de codificação ⇒ Veja o curso
• Siga-nos: Twitter | Linkedin | Boletim de Notícias