Shell script: um guia básico

Shell script (sh) é uma linguagem de script usada em ambiente de linha de comando. Ela permite automatizar comandos de terminal em sistemas baseados em Unix, como Linux e MacOS.

Neste artigo, você aprenderá alguns dos comandos básicos para criar seus primeiros scripts “.sh“. Vamos lá?

Primeiros passos

Scripts são arquivos de texto que devem ser salvos com a extensão “.sh“. Por exemplo:

meu_script_shell.sh

Para executá-lo, o sistema deve ter a permissão de execução. Para isso, acesse o terminal, acesse o diretório em que o script se encontra (use o comando cd) e rode o comando:

chmod +x meu_script_shell.sh

Para executar o script, no terminal, digite:

./meu_script_shell.sh

Podemos ainda executar o programa, chamando no terminal:

sh meu_script_shell.sh

Comandos básicos em Shell Script

Agora, vamos criar um script básico que apenas exibe uma mensagem na tela. Crie um novo arquivo chamado ‘teste.sh‘. Agora adicione as seguintes linhas de código:

#!/bin/sh  
# a linha acima declara o bin que executará o script
          
clear                
# a linha acima executa um comando shell que limpa a tela

echo "Olá mundo!"    
# a linha acima escreve a mensagem "Olá mundo"

# comentários são feitos com '#'

Ao executá-lo, veremos:

Criando variáveis em Shell Script

Podemos criar uma variável apenas inserindo um nome e atribuindo um valor com o operador “=”. Note que não podemos ter espaços entre o nome da variável, o operador “=” e o valor atribuído. Veja:

#!/bin/sh

mensagem="Olá mundo!"

echo "A mensagem é: $mensagem"

Observe o resultado:

Note que para chamar as variáveis, precisamos declarar um cifrão “$” antes de seu nome. Entretanto, esse cifrão não é necessário na hora de declará-la.

Recebendo argumentos

Podemos receber argumentos enviados na chamada do programa usando as variáveis $1, $2, $3, … $9:

#!/bin/sh  

echo "Parâmetros digitados: $1 $2 $3"

Estruturas condicionais

Estruturas condicionais podem ser aplicadas usando as estruturas if, elif e else. Veja a sintaxe:

#!/bin/sh  

if [ condicao ]; then
	echo '...'
elif [ outra_condicao ]; then
	echo '...'
else
	echo '...'
fi

Condições são aplicadas entre colchetes [ ]. Após cada condição, devemos adicionar “; then“. Além disso, ao final precisamos adicionar o comando “fi“.

Note que para avaliarmos uma condição, precisamos primeiro conhecer os operadores relacionais, lógicos ou aritméticos.

Operadores relacionais

Para comparar valores, precisamos utilizar os operadores relacionais. São eles:

Operador	Definição
–eq	Igual
–ne	Diferente
–gt	Maior que
–lt	Menor que
–ge	Maior ou igual que
–le	Menor ou igual que

Observe um exemplo com o operador -gt (greater than/maior que):

#!/bin/sh  

x=10
y=20

# verifica se x é maior que y
if [ $x -gt $y ]; then
	echo 'x maior que y'
fi


# verifica se y é maior que x
if [ $y -gt $x ]; then
	echo 'y maior que x'
fi

Veja que será exibido:

Note que poderíamos, fazer isso usando uma única estrutura condicional, usando elif:

#!/bin/sh  

x=10
y=20

# verifica se x é maior que y
if [ $x -gt $y ]; then
	echo 'x maior que y'
elif [ $y -gt $x ]; then
	echo 'y maior que x'
fi

Podemos ainda adicionar uma condição final, caso nenhuma outra condição seja verdadeira:

#!/bin/sh  

x=10
y=10

# verifica se x é maior que y
if [ $x -gt $y ]; then
	echo 'x maior que y'
elif [ $y -gt $x ]; then
	echo 'y maior que x'
else
	echo "x é igual a y"
fi

Operadores lógicos

Já os osperadores lógicos permitem realizar múltiplas comparações. Eles podem ser:

Operadores	Descrição	Exemplos
!	Diferente	[ ! $x = 10 ] Verifica se o valor de x é diferente de 10.
-o	ou (or)	[ $x = 10 -o $x = 20 ] Verifica se o valor de x é igual a 10 ou 20
-a	e (and)	[ $x -gt 0 -a $x -lt 10 ] Verifica se o valor de x é maior que 0 e menor que 10.

Observe um exemplo:

#!/bin/sh  

x=6

if [ $x -gt 0 -a $x -lt 10 ]; then
	echo 'x é maior que 0 e menor que 10'
fi

Operadores aritméticos

Operadores aritméticos permitem realizar operações matemáticas em Shell Script. Eles podem ser:

Operador	Descrição	Exemplo
+	Adição	$(expr 10 + 10)  # 20
-	Subtração	$(expr 120 - 20)  # 100
*	Multiplicação	$(expr 10 * 7) # 70
/	Divisão	$(expr 10 / 2)  # 5
%	Módulo	$(expr 11 % 2)  # 1
=	Igualdade	Note que: x=10 atribui o valor 10 à variável x. Enquanto: [ $x = 10 ], verifica se a variável $x é igual a 10
!=	Diferente	[ $x != 2 ] A variável x é diferente de 2?

Observe como podemos fazer uma simples soma:

#!/bin/sh  

x=10
y=10
soma=$(expr $x + $y )

echo "A soma de $x + $y é igual a $soma"

Estruturas de repetição

Há duas principais estruturas de repetição: for e while.

Observe um exemplo usando o comando for:

#!/bin/sh  

for ((i=1; i<5; i++))
do
    echo $i
done

Veja como podemos usar for para pegar todos os argumentos enviados na chamada do script:

#!/bin/sh  

# para cada argumento como $i
for i in "$@" 
do
	echo $i
done

Observe como podemos usar o comando while para criar um menu de seleção:

#!/bin/sh  

echo "Menu de seleção:"
echo "1. Exibir mensagem de saudação"
echo "2. Exibir o dia e a hora"
echo "3. Sair"

while read -p "Qual opção você deseja? " entrada
do
    if [ $entrada -eq 1 ]; then
        echo "Bem-vindo(a)!"
        break
    elif [ $entrada -eq 2 ]; then
    	date
    	break
    else
        echo "Até mais!"
        break
    fi
done

Automatizando comandos com Shell Script

Podemos usar qualquer comando de terminal dentro de um arquivo “.sh”. Por isso, podemos utilizar esse tipo de script para automatizar tarefas administrativas ou até mesmo execução múltipla de scripts.

Lendo todos os arquivos de um diretório

Podemos ler todos os arquivos de um diretório usando o comando “ls”. Veja:

#!/bin/sh  

arquivos=$(ls)

echo $arquivos

Este comando irá listar todo o conteúdo do diretório atual.

Agora, vamos fazer algo mais avançado. Vamos concatenar vários comandos em sequência.

#!/bin/sh  

arquivos=$(mkdir teste && cd teste && echo 'teste' > exemplo.txt && ls)

echo $arquivos

Acima, estamos criando uma pasta chamada teste com o comando mkdir, depois entramos nessa pasta e escrevemos a palavra “teste” que será salva em um arquivo chamado “exemplo.txt”. Por fim, executamos o comando “ls” para ver se o arquivo realmente foi criado.

Note que ao executar o código, você verá apenas isto:

De fato, o arquivo desejado foi criado. Podemos perceber isso, executando novamente o código (o sistema retornará um erro, dizendo que a pasta já existe).

Lendo vários arquivos de texto usando shell script

Agora, vamos criar vários arquivos de texto em um diretório e lê-los usando shell script:

#!/bin/sh  

echo 'teste1' > exemplo1.txt 
echo 'teste2' > exemplo2.txt

arquivos=$(ls *txt)


for i in $arquivos
do
	echo $i
done 

Note que o operador “>” joga o resultado impresso na tela para um arquivo.

Conseguimos detectar os arquivos, mas como podemos fazer para lê-los? Basta usar o comando “cat” no lugar de “echo”.

#!/bin/sh  

echo 'teste1' > exemplo1.txt 
echo 'teste2' > exemplo2.txt

arquivos=$(ls *txt)


for i in $arquivos
do
	cat $i
done 

Podemos ainda gravá-lo em um único arquivo, usando o operador “>>”, que joga o resultado da execução para um arquivo (modo incremental).

No exemplo a seguir, vamos ler todos os arquivos com cat e gravá-los em um outro arquivo chamado “todos_exemplos.txt”:

#!/bin/sh  

echo 'teste1' > exemplo1.txt 
echo 'teste2' > exemplo2.txt

arquivos=$(ls *txt)


for i in $arquivos
do
	cat $i >> todos_exemplos.txt
done 

Automatizando a execução de scripts Python

Com tudo que aprendemos neste artigo, podemos por exemplo, automatizar a execução de múltiplos scripts Python ou de um mesmo script que deve ser executado com diferentes parâmetros.

Por exemplo, digamos que você deseja realizar várias análises com arquivos no formato “txt”. Você poderia fazer isso com “.sh”, mas digamos que um script Python foi feito por um colega seu, e você deseja usar esse código (afinal, você não precisa “reinventar a roda”). O script que seu colega fez é este:

import sys

argumentos = sys.argv

for i in range(len(argumentos)):
	if i != 0:
		print("Processando arquivo", argumentos[i])

O código Python acima é bem simples. Ele apenas recebe um argumento com o nome de um arquivo de entrada e faz o processamento dele (neste caso, não há processamento real, apenas uma mensagem na tela de que vamos fazer isso).

Como podemos automatizar a leitura de muitos arquivos “.txt”?

Podemos fazer isso com um shell script.

#!/bin/sh  

arquivos=$(ls *txt)


for i in $arquivos
do
	python3 script.py $i
done 

Aqui, lemos todos os arquivos de texto no diretório atual. A seguir, usamos o comando for para ler cada um deles e executar o script Python passando cada arquivo como parâmetro. Veja o resultado:

Executando comandos em background

Agora, digamos que os scripts Python que você deseja automatizar sejam bastante pesados. No exemplo acima, a execução será sequencial, logo um dependerá que outro tenha terminado para que possa começar sua execução.

Você pode executar múltiplos comandos em background usando o comando nohup e o operador &. Veja:

#!/bin/sh  

arquivos=$(ls *txt)


for i in $arquivos
do
	nohup python3 script.py $i &
done 

Neste caso, o resultado da execução será gravado no arquivo “nohup.out”. Além disso, se houver erros na execução dos scripts, eles serão gravados no arquivo “nohup.err”.

Observe que as mensagens que seriam exibidas estão no arquivo “nohup.out”:

Conclusões

Aqui apresentamos alguns exemplos de comandos SH. O Shell Script pode ser uma ferramenta fundamental para usuários de sistemas baseados em Unix que desejam automatizar tarefas no sistema operacional. Para saber mais, execute no terminal sh --help. Até mais!