Como Definir Valores Padrão em Scripts Bash

ShellBeginner
Pratique Agora

Introdução

Definir valores padrão em scripts Bash é uma habilidade crucial para criar scripts de shell robustos e fáceis de usar. Este tutorial irá guiá-lo através do processo de lidar com parâmetros ausentes ou opcionais, fornecendo valores padrão, garantindo que seus scripts possam lidar graciosamente com uma variedade de cenários de entrada.

Ao final deste laboratório, você será capaz de escrever scripts Bash que funcionem bem mesmo quando os usuários não fornecerem todos os parâmetros de entrada esperados.

Compreendendo os Valores Padrão em Bash

Ao escrever scripts Bash, você frequentemente precisa que seus scripts funcionem mesmo quando certos parâmetros de entrada estão ausentes. Os valores padrão fornecem uma solução, oferecendo opções de fallback quando as variáveis não são explicitamente definidas.

Por que os Valores Padrão Importam

Os valores padrão em scripts Bash servem a vários propósitos importantes:

  • Eles impedem que seu script falhe quando a entrada esperada está ausente
  • Eles tornam seus scripts mais fáceis de usar, reduzindo os parâmetros necessários
  • Eles permitem que seus scripts tenham um comportamento sensato em diferentes ambientes
  • Eles simplificam o desenvolvimento e teste de scripts

Criando um Script Simples

Vamos criar um script Bash simples para demonstrar a necessidade de valores padrão. Siga estes passos:

  1. Abra o terminal WebIDE
  2. Crie um novo diretório para nosso projeto:
mkdir -p ~/project/bash_defaults
cd ~/project/bash_defaults
  1. Usando o WebIDE, crie um novo arquivo chamado greeting.sh no diretório bash_defaults com o seguinte conteúdo:
#!/bin/bash

## A simple greeting script
NAME=$1
echo "Hello, $NAME!"
  1. Torne o script executável:
chmod +x greeting.sh
  1. Agora execute o script com um parâmetro de nome:
./greeting.sh Alice

Você deve ver a saída:

Hello, Alice!
  1. Agora tente executar o script sem nenhum parâmetro:
./greeting.sh

Você deve ver a saída:

Hello, !

Observe que a saudação parece incompleta quando nenhum nome é fornecido. Este é um cenário perfeito onde os valores padrão seriam úteis para tornar nosso script mais robusto.

No próximo passo, modificaremos este script para usar valores padrão, de modo que funcione bem mesmo quando os parâmetros estiverem ausentes.

Técnicas Básicas de Valor Padrão

Agora que entendemos por que os valores padrão são importantes, vamos aprender diferentes maneiras de definir valores padrão em scripts Bash. Começaremos com as técnicas mais comuns.

O Operador de Substituição de Parâmetro (:-)

A maneira mais comum de definir valores padrão em Bash é usando o operador :- com a seguinte sintaxe:

${variable:-default_value}

Isso significa "use o valor de variable se estiver definido e não estiver vazio, caso contrário, use default_value".

Vamos modificar nosso script de saudação para incluir um valor padrão:

  1. Abra o arquivo greeting.sh no WebIDE e atualize-o com o seguinte conteúdo:
#!/bin/bash

## A greeting script with default value
NAME=${1:-"World"}
echo "Hello, $NAME!"
  1. Salve o arquivo e execute o script com um parâmetro:
./greeting.sh Alice

Você deve ver:

Hello, Alice!
  1. Agora execute o script sem nenhum parâmetro:
./greeting.sh

Você deve ver:

Hello, World!

O script agora usa "World" como o valor padrão quando nenhum nome é fornecido, tornando-o muito mais fácil de usar.

Criando um Script Mais Complexo

Vamos criar um script mais complexo que recebe os usuários com uma mensagem personalizável e a hora do dia. Usaremos valores padrão para ambos os parâmetros:

  1. Crie um novo arquivo chamado welcome.sh no diretório bash_defaults com o seguinte conteúdo:
#!/bin/bash

## A welcome script with multiple default values
NAME=${1:-"User"}
GREETING=${2:-"Welcome"}
TIME_OF_DAY=${3:-"today"}

echo "$GREETING, $NAME! How are you doing $TIME_OF_DAY?"
  1. Torne o script executável:
chmod +x welcome.sh
  1. Execute o script com diferentes combinações de parâmetros:
./welcome.sh

Saída:

Welcome, User! How are you doing today?
./welcome.sh Bob

Saída:

Welcome, Bob! How are you doing today?
./welcome.sh Bob "Good morning"

Saída:

Good morning, Bob! How are you doing today?
./welcome.sh Bob "Good morning" "this fine afternoon"

Saída:

Good morning, Bob! How are you doing this fine afternoon?

Como você pode ver, os valores padrão tornam seus scripts muito mais flexíveis, funcionando com qualquer número de parâmetros fornecidos.

Trabalhando com Variáveis de Ambiente e Valores Padrão

Em muitos cenários de script Bash, você precisará trabalhar com variáveis de ambiente. Os valores padrão são especialmente úteis quando você deseja que seu script funcione mesmo que certas variáveis de ambiente não estejam definidas.

Valores Padrão para Variáveis de Ambiente

Variáveis de ambiente são frequentemente usadas para configuração em scripts de shell. Vamos criar um script que usa variáveis de ambiente com valores padrão:

  1. Crie um novo arquivo chamado config.sh no diretório bash_defaults com o seguinte conteúdo:
#!/bin/bash

## Access environment variables with default values
USERNAME=${USER:-"anonymous"}
WORKING_DIR=${PWD:-"/home/labex"}
EDITOR=${VISUAL:-${EDITOR:-"nano"}}

echo "Current user: $USERNAME"
echo "Working directory: $WORKING_DIR"
echo "Preferred editor: $EDITOR"
  1. Torne o script executável:
chmod +x config.sh
  1. Execute o script:
./config.sh

Você deve ver uma saída semelhante a:

Current user: labex
Working directory: /home/labex/project/bash_defaults
Preferred editor: nano

Observe como aninhamos valores padrão para a variável EDITOR. Este script primeiro verifica se a variável de ambiente VISUAL está definida e, se não estiver, verifica a variável EDITOR. Se nenhuma estiver definida, ele assume "nano" por padrão.

Criando um Script de Configuração

Agora, vamos criar um script mais prático que configura um aplicativo usando variáveis de ambiente com valores padrão:

  1. Crie um novo arquivo chamado app_config.sh no diretório bash_defaults com o seguinte conteúdo:
#!/bin/bash

## Application configuration script using default values
APP_NAME=${APP_NAME:-"MyApp"}
APP_VERSION=${APP_VERSION:-"1.0.0"}
APP_PORT=${APP_PORT:-8080}
APP_ENV=${APP_ENV:-"development"}
LOG_LEVEL=${LOG_LEVEL:-"info"}

echo "Starting $APP_NAME v$APP_VERSION"
echo "Configuration:"
echo "  Port: $APP_PORT"
echo "  Environment: $APP_ENV"
echo "  Log Level: $LOG_LEVEL"

## Create a config file with these settings
echo "Creating configuration file..."
cat > app.conf << EOF
APP_NAME=$APP_NAME
APP_VERSION=$APP_VERSION
APP_PORT=$APP_PORT
APP_ENV=$APP_ENV
LOG_LEVEL=$LOG_LEVEL
EOF

echo "Configuration file created at $(pwd)/app.conf"
  1. Torne o script executável:
chmod +x app_config.sh
  1. Execute o script com valores padrão:
./app_config.sh

Você deve ver a saída sobre a configuração padrão.

  1. Agora execute-o com algumas variáveis de ambiente definidas:
APP_NAME="WebService" APP_PORT=3000 APP_ENV="production" ./app_config.sh

Você deve ver que o script usa os valores que você forneceu para algumas configurações e os padrões para outras.

  1. Verifique o conteúdo do arquivo de configuração:
cat app.conf

Este exemplo prático mostra como os valores padrão em Bash ajudam a criar scripts de configuração flexíveis que funcionam com ou sem valores especificados pelo usuário.

Técnicas Avançadas de Valor Padrão

Agora que você entende os conceitos básicos de como definir valores padrão em Bash, vamos explorar algumas técnicas avançadas que tornarão seus scripts ainda mais poderosos e flexíveis.

O Operador de Atribuição :=

O operador := não apenas substitui um valor padrão, mas também atribui esse valor à variável se ela não estiver definida. Isso é útil quando você deseja que a variável mantenha seu valor padrão para uso posterior.

  1. Crie um novo arquivo chamado assign_default.sh no diretório bash_defaults com o seguinte conteúdo:
#!/bin/bash

## Demonstrate the := assignment operator
echo "Before assignment, NAME = $NAME"

## This assigns the default value to NAME if it's unset
: ${NAME:="DefaultUser"}

echo "After assignment, NAME = $NAME"

## Now use the variable in a function
greet() {
  echo "Hello, $NAME!"
}

greet
  1. Torne o script executável:
chmod +x assign_default.sh
  1. Execute o script sem definir NAME:
./assign_default.sh

Você deve ver:

Before assignment, NAME =
After assignment, NAME = DefaultUser
Hello, DefaultUser!
  1. Agora defina NAME antes de executar:
NAME="Alice" ./assign_default.sh

Você deve ver:

Before assignment, NAME = Alice
After assignment, NAME = Alice
Hello, Alice!

Encadeando Valores Padrão

Às vezes, você pode querer verificar várias fontes para um valor antes de recorrer a um padrão codificado. Você pode encadear valores padrão para conseguir isso:

  1. Crie um novo arquivo chamado chain_defaults.sh no diretório bash_defaults com o seguinte conteúdo:
#!/bin/bash

## Read config file if it exists
if [[ -f "./user.conf" ]]; then
  source "./user.conf"
fi

## Chain default values: command line arg -> config file -> environment var -> hard-coded default
USERNAME=${1:-${CONFIG_USER:-${USER:-"guest"}}}
LANGUAGE=${2:-${CONFIG_LANG:-${LANG:-"en_US"}}}

echo "Hello, $USERNAME! Your language is set to $LANGUAGE."
  1. Torne o script executável:
chmod +x chain_defaults.sh
  1. Crie um arquivo de configuração para teste:
echo "CONFIG_USER=ConfigUser" > user.conf
echo "CONFIG_LANG=es_ES" >> user.conf
  1. Teste o script com diferentes combinações:
## Use defaults from the config file
./chain_defaults.sh
## Override with command line arguments
./chain_defaults.sh CommandLineUser fr_FR
## Remove config file to test falling back to environment variables
rm user.conf
./chain_defaults.sh

Valores Padrão Condicionais

Você também pode usar expressões condicionais para definir diferentes valores padrão com base em condições:

  1. Crie um novo arquivo chamado conditional_defaults.sh no diretório bash_defaults com o seguinte conteúdo:
#!/bin/bash

## Get the current hour (24-hour format)
HOUR=$(date +%H)

## Set default greeting based on time of day
if ((HOUR < 12)); then
  DEFAULT_GREETING="Good morning"
elif ((HOUR < 18)); then
  DEFAULT_GREETING="Good afternoon"
else
  DEFAULT_GREETING="Good evening"
fi

## Use the conditional default if no greeting is provided
GREETING=${1:-"$DEFAULT_GREETING"}
NAME=${2:-"User"}

echo "$GREETING, $NAME!"
echo "The current time is $(date +%H:%M)."
  1. Torne o script executável:
chmod +x conditional_defaults.sh
  1. Execute o script para ver como ele escolhe uma saudação padrão com base na hora do dia:
./conditional_defaults.sh
  1. Substitua a saudação padrão:
./conditional_defaults.sh "Hello" "World"

Essas técnicas avançadas oferecem mais flexibilidade ao trabalhar com valores padrão em Bash, permitindo que você crie scripts mais sofisticados e fáceis de usar.

Aplicando Valores Padrão em um Script do Mundo Real

Agora que cobrimos várias técnicas para definir valores padrão, vamos juntar tudo em um script prático que você pode usar em um cenário do mundo real.

Criaremos um script de backup que usa valores padrão para várias opções de configuração. Este script demonstrará como os valores padrão tornam seus scripts mais flexíveis e fáceis de usar.

Criando um Script de Backup

  1. Crie um novo arquivo chamado backup.sh no diretório bash_defaults com o seguinte conteúdo:
#!/bin/bash

## Backup script with default values for all parameters

## Source directories to backup (comma-separated) - default to current directory
SRC_DIRS=${1:-$(pwd)}

## Destination directory for backups - default to ~/backups
BACKUP_DIR=${2:-"$HOME/backups"}

## Backup filename prefix - default to "backup"
PREFIX=${3:-"backup"}

## Maximum number of backups to keep - default to 5
MAX_BACKUPS=${4:-5}

## Create destination directory if it doesn't exist
mkdir -p "$BACKUP_DIR"

## Generate timestamp for the backup filename
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/${PREFIX}_${TIMESTAMP}.tar.gz"

echo "Starting backup process..."
echo "Source: $SRC_DIRS"
echo "Destination: $BACKUP_FILE"

## Create the backup archive (we'll simulate this for the lab)
echo "Creating backup archive..."
echo "tar -czf $BACKUP_FILE $SRC_DIRS" > "$BACKUP_DIR/last_backup_command.txt"
touch "$BACKUP_FILE" ## Just create an empty file for demonstration

## Clean up old backups if we have more than MAX_BACKUPS
echo "Checking for old backups to remove..."
NUM_BACKUPS=$(ls -1 "$BACKUP_DIR"/${PREFIX}_*.tar.gz 2> /dev/null | wc -l)
if ((NUM_BACKUPS > MAX_BACKUPS)); then
  NUM_TO_DELETE=$((NUM_BACKUPS - MAX_BACKUPS))
  echo "Removing $NUM_TO_DELETE old backup(s)..."
  ls -1t "$BACKUP_DIR"/${PREFIX}_*.tar.gz | tail -n "$NUM_TO_DELETE" | while read file; do
    echo "Would delete: $file (simulation)"
  done
else
  echo "No old backups need to be removed (keeping $NUM_BACKUPS of $MAX_BACKUPS maximum)"
fi

echo "Backup process completed!"
echo "Backup saved to: $BACKUP_FILE"
  1. Torne o script executável:
chmod +x backup.sh
  1. Crie os diretórios necessários para teste:
mkdir -p ~/backups
mkdir -p ~/test_data
echo "Test file 1" > ~/test_data/file1.txt
echo "Test file 2" > ~/test_data/file2.txt

Testando o Script de Backup

Agora, vamos testar nosso script de backup com diferentes combinações de parâmetros para ver como os valores padrão funcionam na prática:

  1. Execute o script com todos os valores padrão:
./backup.sh

Isso fará o backup do diretório atual para ~/backups com o prefixo "backup".

  1. Execute o script especificando um diretório de origem:
./backup.sh ~/test_data

Isso fará o backup do diretório test_data usando os outros valores padrão.

  1. Execute o script com origem e destino personalizados:
./backup.sh ~/test_data ~/project/bash_defaults/my_backups
  1. Execute o script com todos os parâmetros especificados:
./backup.sh ~/test_data ~/project/bash_defaults/my_backups project_backup 3

Este exemplo mostra como os valores padrão tornam seus scripts flexíveis - os usuários podem especificar quantos ou poucos parâmetros forem necessários, e seu script ainda funcionará corretamente.

Verifique os Resultados

Após executar o script de backup com diferentes parâmetros, você pode verificar os resultados:

## Check the default backup location
ls -la ~/backups

## Check the custom backup location (if you used it)
ls -la ~/project/bash_defaults/my_backups

Ao usar valores padrão consistentemente em seus scripts, você cria ferramentas que são mais fáceis de usar e adaptáveis a diferentes ambientes e casos de uso.

Resumo

Neste laboratório, você aprendeu como definir valores padrão em scripts Bash, uma habilidade fundamental para criar scripts robustos e fáceis de usar. Ao longo do laboratório, você:

  • Criou scripts simples usando técnicas básicas de valor padrão com o operador :-
  • Trabalhou com variáveis de ambiente e valores padrão
  • Explorou técnicas avançadas de valor padrão, incluindo o operador de atribuição := e padrões condicionais
  • Desenvolveu um script de backup prático que demonstra como os valores padrão tornam seus scripts mais flexíveis

Essas técnicas permitem que seus scripts funcionem bem mesmo quando os usuários não fornecem todos os parâmetros esperados, tornando-os mais resilientes e fáceis de usar. Os valores padrão também simplificam o desenvolvimento e os testes de scripts, reduzindo a necessidade de validação abrangente de entrada.

Ao continuar a escrever scripts Bash, lembre-se de usar valores padrão livremente para melhorar a experiência do usuário e a robustez de seus scripts. Essa prática tornará seus scripts mais profissionais e úteis em uma variedade de ambientes e cenários.