Bem-vindo à sua primeira aula prática de Shell Script! Nesta aula, vamos dar os primeiros passos para criar um script Bash do zero. Você verá que um script nada mais é do que um arquivo de texto com uma sequência de comandos que o interpretador Bash executa. Mas, para que isso funcione corretamente, precisamos entender alguns elementos essenciais: o shebang, as permissões de execução, as diferentes maneiras de executar um script e, claro, como documentar nosso código com comentários.

Dominar esses fundamentos é crucial porque eles formam a base de qualquer script que você escreverá daqui para frente. Sem o shebang, por exemplo, o sistema pode não saber qual interpretador usar; sem a permissão de execução, o script não será executado diretamente. E os comentários, embora não afetem a execução, são vitais para manter o código legível e manutenível. Vamos explorar cada um desses tópicos em detalhes, com exemplos práticos que você pode testar no seu terminal.

Shebang (#!/bin/bash)

O shebang é a primeira linha de um script e começa com os caracteres #! seguidos pelo caminho do interpretador. No nosso caso, #!/bin/bash indica que o script deve ser executado usando o Bash localizado em /bin/bash. O nome "shebang" vem da combinação de "hash" (#) e "bang" (!). Quando o kernel do Linux encontra um arquivo executável que começa com shebang, ele usa o interpretador especificado para executar o restante do arquivo.

É importante notar que o shebang deve ser exatamente a primeira linha do arquivo. Se houver qualquer espaço ou caractere antes, ele não será reconhecido. Além disso, é possível usar outros interpretadores, como #!/bin/sh (que geralmente aponta para o shell padrão do sistema) ou #!/usr/bin/env python3 para scripts Python. Usar env é uma prática comum para scripts portáveis, pois localiza o interpretador no PATH. No entanto, para scripts Bash, #!/bin/bash é a escolha mais direta e garante que o Bash seja usado.

#!/bin/bash
# Este é um comentário
echo "Olá, mundo!"

No exemplo acima, o shebang é a primeira linha. Sem ele, se você tentar executar o script diretamente, o sistema tentará interpretá-lo com o shell atual, o que pode funcionar por engano, mas não é recomendado. Com o shebang, garantimos que o Bash seja usado, independentemente do shell ativo.

Tornando executável (chmod +x)

Antes de executar um script diretamente, é necessário dar a ele permissão de execução. No Linux, as permissões de arquivo controlam quem pode ler, escrever e executar um arquivo. O comando chmod (change mode) é usado para alterar essas permissões. A forma mais comum é chmod +x script.sh, que adiciona a permissão de execução para o usuário, grupo e outros, dependendo das configurações do sistema.

As permissões são representadas por três grupos de três caracteres: dono (u), grupo (g) e outros (o). Cada grupo pode ter permissões de leitura (r), escrita (w) e execução (x). Ao usar chmod +x, você está adicionando a permissão de execução para todos os grupos. Você também pode especificar para quem deseja dar permissão, por exemplo, chmod u+x dá permissão apenas ao dono. É uma boa prática dar permissão de execução apenas ao dono, a menos que o script precise ser executado por outros usuários.

Para verificar as permissões de um arquivo, use ls -l. A saída mostrará algo como -rw-r--r-- para um arquivo sem permissão de execução e -rwxr-xr-x para um executável. O primeiro caractere indica o tipo de arquivo (- para regular, d para diretório).

# Antes de tornar executável
ls -l meu_script.sh
# -rw-r--r-- 1 usuario grupo 0 Jan  1 00:00 meu_script.sh

chmod +x meu_script.sh
ls -l meu_script.sh
# -rwxr-xr-x 1 usuario grupo 0 Jan  1 00:00 meu_script.sh

No exemplo, o comando ls -l mostra as permissões. Depois de chmod +x, as permissões mudam para -rwxr-xr-x, indicando que agora o arquivo é executável. Sem isso, tentar executar o script com ./meu_script.sh resultará em um erro de permissão negada (Permission denied).

Executando

Existem várias maneiras de executar um script Bash. A mais comum é usando o caminho relativo ou absoluto, precedido por ./ (para o diretório atual). Por exemplo, ./meu_script.sh executa o script no diretório atual. Isso funciona apenas se o arquivo tiver permissão de execução e o shebang estiver presente. Outra forma é chamar o interpretador explicitamente: bash meu_script.sh. Nesse caso, o shebang não é necessário, pois o interpretador é fornecido na linha de comando. Essa abordagem é útil se o arquivo não for executável ou se você quiser usar um interpretador específico.

Também é possível executar um script sem torná-lo executável usando sh meu_script.sh (que pode apontar para dash, não bash) ou source meu_script.sh (ou . meu_script.sh), que executa o script no shell atual, sem criar um subshell. Isso é útil quando você deseja que variáveis definidas no script persistam no ambiente atual. No entanto, para scripts normais, a execução direta é preferida.

Quando você executa um script diretamente, o sistema cria um novo processo (subshell) para executá-lo. Isso significa que as variáveis definidas no script não afetam o shell original. Se você precisar que o script modifique o ambiente, use source. Vamos ver um exemplo de execução:

# Suponha que temos um script chamado saudacao.sh
#!/bin/bash
echo "Olá, seja bem-vindo!"

# Executar diretamente
./saudacao.sh
# Saída: Olá, seja bem-vindo!

# Executar com bash
bash saudacao.sh
# Saída: Olá, seja bem-vindo!

# Executar com source (no shell atual)
source saudacao.sh
# Saída: Olá, seja bem-vindo!

No exemplo, as três formas executam o script e produzem a mesma saída. A diferença está no contexto: ./saudacao.sh e bash saudacao.sh criam um subshell, enquanto source executa no shell atual. Para a maioria dos scripts, a execução direta é suficiente.

Comentários

Comentários são linhas no script que são ignoradas pelo interpretador. Eles começam com # e vão até o final da linha. Comentários são essenciais para documentar o propósito do script, explicar trechos de código e tornar o código mais legível para outras pessoas (e para você mesmo no futuro). É uma boa prática adicionar um cabeçalho no início de cada script com uma descrição, autor, data e versão.

Além de comentários de linha única, você pode usar # no final de uma linha de comando para adicionar um comentário inline. Por exemplo, echo "Olá" # imprime saudação. No entanto, o shell interpreta o # como início de comentário somente se ele estiver no início de uma palavra. Se houver espaços antes, é seguro. Mas cuidado: dentro de strings, o # não inicia um comentário, a menos que esteja no início da palavra.

Vamos ver um exemplo de script com comentários:

#!/bin/bash
# Script: saudacao.sh
# Descrição: Exibe uma saudação personalizada.
# Autor: Maria Silva
# Data: 2025-03-01

# Define o nome padrão
nome="Mundo"

# Verifica se um argumento foi passado
if [ $# -gt 0 ]; then
  nome="$1"  # Usa o primeiro argumento
fi

# Exibe a saudação
echo "Olá, $nome!"

Neste script, os comentários explicam o propósito de cada seção. O shebang é a primeira linha, seguido por um cabeçalho de comentários. Depois, comentários inline ajudam a entender o que cada parte faz. Comentários não afetam a execução, mas são fundamentais para a manutenção do código.

Boas práticas e observações finais

Ao criar scripts Bash, siga algumas boas práticas: sempre use o shebang, mesmo que o script seja simples; torne o script executável apenas se for necessário executá-lo diretamente; use comentários para documentar o que o script faz, especialmente se ele for complexo; e teste o script em um ambiente seguro antes de usá-lo em produção. Além disso, lembre-se de que o Bash é sensível a espaços e caracteres especiais, então use aspas quando necessário.

Outra recomendação é nomear seus scripts com a extensão .sh para indicar que são scripts de shell, embora isso não seja obrigatório. Também é útil colocar scripts em um diretório que esteja no PATH, como /usr/local/bin, se você quiser executá-los de qualquer lugar, mas isso requer privilégios de administrador. Para scripts pessoais, um diretório como ~/bin é adequado.

Com esses fundamentos, você está pronto para escrever scripts mais complexos. Na próxima aula, vamos explorar variáveis e entrada de dados, que permitirão que seus scripts interajam com o usuário e processem informações dinamicamente.

Referências

Exercícios

  1. Crie um script chamado primeiro.sh que exiba a mensagem "Meu primeiro script". Inclua o shebang e um comentário de cabeçalho.

    2. ✓ Resposta: 
    #!/bin/bash
# Script: primeiro.sh
# Exibe uma mensagem simples.
echo "Meu primeiro script"
  2. Explique a diferença entre executar um script com ./script.sh e bash script.sh.

    3. ✓ Resposta: Com ./script.sh, o sistema usa o shebang para determinar o interpretador. Se o arquivo não for executável, ocorre erro. Com bash script.sh, você chama o interpretador bash explicitamente, sem precisar da permissão de execução. O shebang é ignorado nesse caso.
  3. O que acontece se você omitir o shebang em um script e tentar executá-lo com ./script.sh?

    4. ✓ Resposta: O sistema tentará executar o arquivo usando o shell atual (por exemplo, bash), o que pode funcionar se o conteúdo for compatível. No entanto, se o shell atual não for bash, pode ocorrer erro de sintaxe. É sempre recomendável incluir o shebang para garantir o interpretador correto.
  4. Qual comando você usaria para dar permissão de execução apenas ao dono do arquivo? Dê um exemplo.

    5. ✓ Resposta: O comando é chmod u+x nome_do_script.sh. Exemplo: chmod u+x meu_script.sh.
  5. Escreva um script que contenha pelo menos três comentários e um comando echo. Execute-o e descreva a saída.

    6. ✓ Resposta: 
    #!/bin/bash
# Script: comentarios.sh
# Autor: João
# Data: 2025-03-01

# Exibe uma mensagem
echo "Olá, mundo!"
    A saída será: Olá, mundo!