Introdução ao Shell Script: Comandos básicos

Introdução ao Shell Script

Aurélio Marinho Jargas

http://aurelio.net

Introdução ao Shell Script - Aurélio Marinho Jargas

Índice
Sobre o curso.......................................................................................................................1

Apresentação ........................................................................................................................2
O que é o shell............................................................................................................2
Shell script...................................................................................................................3
Antes de começar ........................................................................................................3

O primeiro shell script.........................................................................................................4
Passos para criar um shell script ................................................................................4
.
Problemas na execução do script...............................................................................5
.

O primeiro shell script (melhorado)...................................................................................6
.
Melhorar a saída na tela..............................................................................................6
Interagir com o usuário................................................................................................6
Melhorar o código do script.........................................................................................7

Rebobinando a fita...............................................................................................................8
Variáveis......................................................................................................................8
Detalhes sobre os comandos......................................................................................8
O comando test.........................................................................................................10
Tarefa: script que testa arquivos...............................................................................11

Conceitos mais avançados...............................................................................................12
Recebimento de opções e parâmetros ......................................................................12
Expressões aritméticas ..............................................................................................12
If, for e while..............................................................................................................13

Exercícios...........................................................................................................................15

Mais informações...............................................................................................................18

Respostas dos exercícios.................................................................................................19
testa-arquivos............................................................................................................19
relacao.sh..................................................................................................................19
zerador.sh ..................................................................................................................19
substring.sh...............................................................................................................20
juntatudo.sh...............................................................................................................20
users.sh.....................................................................................................................20
shells.sh.....................................................................................................................20
parametros.sh ............................................................................................................20

i

Sobre o curso
Nome
Introdução a Shell Scripts
Instrutor
Aurélio Marinho Jargas (http://aurelio.net)
Objetivo
Ensinar aos alunos todos os conceitos necessários para poderem fazer sozinhos
scripts simples em shell.
Pré-Requisitos
Noções básicas de informática e operação do sistema pela linha de comando. É
desejado, porém não obrigatório, noções básicas de programação.
Público Alvo
Desenvolvedores, administradores de sistemas, programadores e interessados em
geral.
Duração
8 horas

1

Apresentação
O que é o shell
O shell é o "prompt" da linha de comando do Unix e Linux, é o servo que recebe os
comandos digitados pelo usuário e os executa.

O shell é aquele que aparece logo após digitar-se a senha do usuário e entrar na tela
preta. Ou na interface gráfica, ao clicar no ícone do Xterm, rxvt, Terminal ou Console.

localhost login: root
Password:

Last login: Fri Apr 16 01:57:28 on tty5
[root@localhost root]# _

Ali está o shell, esperando ansiosamente por algum comando para ele poder executar.
Essa é a sua função: esperar e executar. Cada comando digitado é lido, verificado,
interpretado e enviado ao sistema operacional para ser de fato executado.

No Mac OS X, o shell está em Aplicativos > Utilitários > Terminal. No Windows é
preciso instalá-lo com o Cygwin.
Funcionando como uma ponte, o shell é a ligação entre o usuário e o kernel. O kernel é
quem acessa os equipamentos (hardware) da máquina, como disco rígido, placa de vídeo
e modem. Por exemplo, para o usuário ler um arquivo qualquer, toda esta hierarquia é
seguida:

USUÁRIO --> SHELL --> KERNEL --> DISCO RÍGIDO

Para os usuários do Windows, é fácil pensar no shell como um MSDOS melhorado. Ao
invés do C:> aparece um [root@localhost root]#, mas o funcionamento é similar. Basta
digitar um comando, suas opções e apertar a ENTER que ele será executado. O comando
deve estar no PATH, mensagens de aviso são mandadas para a tela e Ctrl+C interrompe o
funcionamento. Isso tudo é igual em ambos.

Mas o shell é muito mais poderoso que seu primo distante. Além dos comandos básicos
para navegar entre diretórios e manipular arquivos, ele também possui todas as estruturas
de uma linguagem de programação, como IF, FOR, WHILE, variáveis e funções. Com isso,
também é possível usar o shell para fazer scripts e automatizar tarefas.

Este será o nosso foco: scripts em shell.

2


Shell script
Um script é um arquivo que guarda vários comandos e pode ser executado sempre que
preciso. Os comandos de um script são exatamente os mesmos que se digita no prompt, é
tudo shell.

Por exemplo, se de tempos em tempos você quer saber informações do sistema como
horário, ocupação do disco e os usuários que estão logados, é preciso digitar três
comandos:

[root@localhost root]# date
[root@localhost root]# df
[root@localhost root]# w

É melhor fazer um script chamado "sistema" e colocar estes comandos nele. O conteúdo
do arquivo "sistema" seria o seguinte:

#!/bin/bash
date
df
w

E para chamar este script, basta agora executar apenas um comando:

[root@localhost root]# sistema

Isso é um shell script. Um arquivo de texto que contém comandos do sistema e pode ser
executado pelo usuário.

Antes de começar
Se você está acessando o sistema como usuário administrador (root), saia e entre como
um usuário normal. É muito perigoso estudar shell usando o superusuário, você pode
danificar o sistema com um comando errado.

Se você não tem certeza qual o seu usuário, use o comando "whoami" para
saber
Como o prompt de usuário normal é diferente para cada um, nos exemplos seguintes será
usado "prompt$" para indicar o prompt da linha de comando.

3

O primeiro shell script
O primeiro shell script a fazer será o "sistema" do exemplo anterior, de simplesmente juntar
três comandos em um mesmo script.

Passos para criar um shell script
1. Escolher um nome para o script

Já temos um nome: sistema.

Use apenas letras minúsculas e evite acentos, símbolos e espaço em branco

2. Escolher o diretório onde colocar o script

Para que o script possa ser executado de qualquer parte do sistema, mova-o para um
diretório que esteja no seu PATH. Para ver quais são estes diretórios, use o comando:

echo $PATH

Se não tiver permissão de mover para um diretório do PATH, deixe-o dentro de
seu diretório pessoal ($HOME).
3. Criar o arquivo e colocar nele os comandos

Use o nano, VI ou outro editor de textos de sua preferência para colocar todos os
comandos dentro do arquivo.

4. Colocar a chamada do shell na primeira linha

A primeira linha do script deve ser:

#!/bin/bash

Para que ao ser executado, o sistema saiba que é o shell quem irá interpretar estes
comandos.

5. Tornar o script um arquivo executável

Use o seguinte comando para que seu script seja reconhecido pelo sistema como um
comando executável:

chmod +x sistema

4


Problemas na execução do script

"Comando não encontrado"

O shell não encontrou o seu script.

Verifique se o comando que você está chamando tem exatamente o mesmo nome
do seu script. Lembre-se que no Unix/Linux as letras maiúsculas e minúsculas são
diferentes, então o comando "SISTEMA" é diferente do comando "sistema".

Caso o nome esteja correto, verifique se ele está no PATH do sistema. O comando
"echo $PATH" mostra quais são os diretórios conhecidos, mova seu script para
dentro de um deles, ou chame-o passando o caminho completo.

Se o script estiver no diretório corrente, chame-o com um "./" na frente, assim:

prompt$ ./sistema

Caso contrário, especifique o caminho completo desde o diretório raiz:

prompt$ /tmp/scripts/sistema

"Permissão Negada"

O shell encontrou seu script, mas ele não é executável.

Use o comando "chmod +x seu-script" para torná-lo um arquivo executável.

"Erro de Sintaxe"

O shell encontrou e executou seu script, porém ele tem erros.

Um script só é executado quando sua sintaxe está 100% correta. Verifique os seus
comandos, geralmente o erro é algum IF ou aspas que foram abertos e não foram
fechados. A própria mensagem informa o número da linha onde o erro foi
encontrado.

5

O primeiro shell script (melhorado)
Nesse ponto, você já sabe o básico necessário para fazer um script em shell do zero e
executá-lo. Mas apenas colocar os comandos em um arquivo não torna este script útil.
Vamos fazer algumas melhorias nele para que fique mais compreensível.

Melhorar a saída na tela
Executar os três comandos seguidos resulta em um bolo de texto na tela, misturando as
informações e dificultando o entendimento. É preciso trabalhar um pouco a saída do script,
tornando-a mais legível.

O comando "echo" serve para mostrar mensagens na tela. Que tal anunciar cada comando
antes de executá-lo?

#!/bin/bash
echo "Data e Horário:"
date
echo
echo "Uso do disco:"
df
echo
echo "Usuários conectados:"
w

Para usar o echo, basta colocar o texto entre "aspas". Se nenhum texto for colocado, uma
linha em branco é mostrada.

Interagir com o usuário
Para o script ficar mais completo, vamos colocar uma interação mínima com o usuário,
pedindo uma confirmação antes de executar os comandos.

#!/bin/bash
echo "Vou buscar os dados do sistema. Posso continuar? [sn] "
read RESPOSTA
test "$RESPOSTA" = "n" && exit
date
echo
df
echo
w

O comando "read" leu o que o usuário digitou e guardou na variável RESPOSTA. Logo em
seguida, o comando "test" verificou se o conteúdo dessa variável era "n". Se afirmativo, o

6


comando "exit" foi chamado e o script foi finalizado. Nessa linha há vários detalhes
importantes:

• O conteúdo da variável é acessado colocando-se um cifrão "$" na frente
• O comando test é útil para fazer vários tipos de verificações em textos e arquivos
• O operador lógico "&&", só executa o segundo comando caso o primeiro tenha sido
OK. O operador inverso é o "||"

Melhorar o código do script
Com o tempo, o script vai crescer, mais comandos vão ser adicionados e quanto maior,
mais difícil encontrar o ponto certo onde fazer a alteração ou corrigir algum erro.

Para poupar horas de estresse, e facilitar as manutenções futuras, é preciso deixar o
código visualmente mais agradável e espaçado, e colocar comentários esclarecedores.

#!/bin/bash
# sistema - script que mostra informações sobre o sistema
# Autor: Fulano da Silva

# Pede uma confirmação do usuário antes de executar
echo "Vou buscar os dados do sistema. Posso continuar? [sn] "
read RESPOSTA

# Se ele digitou 'n', vamos interromper o script
test "$RESPOSTA" = "n" && exit

# O date mostra a data e a hora correntes
date
echo

# O df mostra as partições e quanto cada uma ocupa no disco
df
echo

# O w mostra os usuários que estão conectados nesta máquina
w

Basta iniciar a linha com um "#" e escrever o texto do comentário em seguida. Estas linhas
são ignoradas pelo shell durante a execução. O cabeçalho com informações sobre o script
e seu autor também é importante para ter-se uma visão geral do que o script faz, sem
precisar decifrar seu código.

Também é possível colocar comentários no meio da linha # como este

7

Rebobinando a fita
Agora é hora de fixar alguns dos conceitos vistos no script anterior.

Variáveis
As variáveis são a base de qualquer script. É dentro delas que os dados obtidos durante a
execução do script serão armazenados. Para definir uma variável, basta usar o sinal de
igual "=" e para ver seu valor, usa-se o "echo":

prompt$ VARIAVEL="um dois tres"
prompt$ echo $VARIAVEL
um dois tres
prompt$ echo $VARIAVEL $VARIAVEL
um dois tres um dois tres
prompt$

Não podem haver espaços ao redor do igual "="

Ainda é possível armazenar a saída de um comando dentro de uma variável. Ao invés de
aspas, o comando deve ser colocado entre "$(...)", veja:

prompt$ HOJE=$(date)
prompt$ echo "Hoje é: $HOJE"
Hoje é: Sáb Abr 24 18:40:00 BRT 2004
prompt$ unset HOJE
prompt$ echo $HOJE

prompt$

E finalmente, o comando "unset" apaga uma variável.

Para ver quais as variáveis que o shell já define por padrão, use o comando
"env"

Detalhes sobre os comandos
Diferente de outras linguagens de programação, o shell não usa os parênteses para
separar o comando de seus argumentos, mas sim o espaço em branco. O formato de um
comando é sempre:

COMANDO OPÇÕES PARÂMETROS

O comando "cat" mostra o conteúdo de um arquivo. O comando "cat -n sistema" mostra o
nosso script, com as linhas numeradas. O "-n" é a opção para o comando, que o instrui a
numerar linhas, e "sistema" é o último argumento, o nome do arquivo.

8


O "read" é um comando do próprio shell, já o "date"" é um executável do sistema. Dentro
de um script, não faz diferença usar um ou outro, pois o shell sabe como executar ambos.
Assim, toda a gama de comandos disponíveis no Unix/Linux pode ser usada em scripts!

Há vários comandos que foram feitos para serem usados com o shell, são como
ferramentas. Alguns deles:

Comando Função Opções úteis
cat Mostra arquivo -n, -s
cut Extrai campo -d -f, -c
date Mostra data -d, +'...'
find Encontra arquivos -name, -iname, -type f, -exec
grep Encontra texto -i, -v, -r, -qs, -w -x
head Mostra Início -n, -c
printf Mostra texto nenhuma
rev Inverte texto nenhuma
sed Edita texto -n, s/isso/aquilo/, d
seq Conta Números -s, -f
sort Ordena texto -n, -f, -r, -k -t, -o
tail Mostra Final -n, -c, -f
tr Transforma texto -d, -s, A-Z a-z
uniq Remove duplicatas -i, -d, -u
wc Conta Letras -c, -w, -l, -L

Use "man comando" ou "comando --help" para obter mais informações sobre
cada um deles.

E o melhor, em shell é possível combinar comandos, aplicando-os em seqüência, para
formar um comando completo. Usando o pipe "|" é possível canalizar a saída de um
comando diretamente para a entrada de outro, fazendo uma cadeia de comandos.
Exemplo:

prompt$ cat /etc/passwd | grep root | cut -c1-10
root:x:0:0
operator:x
prompt$

9


O cat mostra o arquivo todo, o grep pega essa saída e extrai apenas as linhas que contêm
a palavra "root" e o cut por sua vez, somente nessas linhas que o grep achou, extrai os 10
primeiros caracteres. Isso funciona como uma estação de tratamento de água, onde ela
entra suja, vai passando por vários filtros que vão tirando as impurezas e sai limpa no final.

E por fim, também é possível redirecionar a saída de um comando para um arquivo ao
invés da tela, usando o operador ">". Para guardar a saída do comando anterior no arquivo
"saida", basta fazer:

prompt$ cat /etc/passwd | grep root | cut -c1-10 > saida
prompt$ cat saida
root:x:0:0
operator:x
prompt$

Cuidado! Shell é tão legal que vicia!

O comando test
O canivete suíço dos comandos do shell é o "test", que consegue fazer vários tipos de
testes em números, textos e arquivos. Ele possui várias opções para indicar que tipo de
teste será feito, algumas delas:

Testes em variáveis Testes em arquivos
-lt Núm. é menor que (LessThan) -d É um diretório
-gt Núm. é maior que (GreaterThan) -f É um arquivo normal
-le Núm. é menor igual (LessEqual) -r O arquivo tem permissão de leitura
-ge Núm. é maior igual (GreaterEqual) -s O tamanho do arquivo é maior que zero
-eq Núm. é igual (EQual) -w O arquivo tem permissão de escrita
-ne Núm. é diferente (NotEqual) -nt O arquivo é mais recente (NewerThan)
= String é igual -ot O arquivo é mais antigo (OlderThan)
!= String é diferente -ef O arquivo é o mesmo (EqualFile)
-n String é não nula -a E lógico (AND)
-z String é nula -o OU lógico (OR)

10


Tarefa: script que testa arquivos
Tente fazer o script "testa-arquivos", que pede ao usuário para digitar um arquivo e testa
se este arquivo existe. Se sim, diz se é um arquivo ou um diretório. Exemplo de uso:

prompt$ testa-arquivos
Digite o arquivo: /naoexiste
O arquivo '/naoexiste' não foi encontrado

Digite o arquivo: /tmp
/tmp é um diretório

Digite o arquivo: /etc/passwd
/etc/passwd é um arquivo

prompt$

11

Conceitos mais avançados
Até agora vimos o básico, o necessário para se fazer um script de funcionalidade mínima.
A seguir, conceitos novos que ampliarão as fronteiras de seus scripts!

Recebimento de opções e parâmetros
Assim como os comandos do sistema que possuem e opções e parâmetros, os scripts
também podem ser preparados para receber dados via linha de comando.

Dentro do script, algumas variáveis especiais são definidas automaticamente, em especial,
"$1" contém o primeiro argumento recebido na linha de comando, "$2" o segundo, e assim
por diante. Veja o script "argumentos":

#!/bin/sh
# argumentos - mostra o valor das variáveis especiais

echo "O nome deste script é: $0"
echo "Recebidos $# argumentos: $*"
echo "O primeiro argumento recebido foi: $1"
echo "O segundo argumento recebido foi: $2"

Ele serve para demonstrar o conteúdo de algumas variáveis especiais, acompanhe:

prompt$ ./argumentos um dois três
O nome deste script é: ./argumentos
Recebidos 3 argumentos: um dois três
O primeiro argumento recebido foi: um
O segundo argumento recebido foi: dois

O acesso é direto, basta referenciar a variável que o valor já estará definido. Assim é
possível criar scripts que tenham opções como --help, --version e outras.

Expressões aritméticas
O shell também sabe fazer contas. A construção usada para indicar uma expressão
aritmética é "$((...))", com dois parênteses.

prompt$ echo $((2*3))
6
prompt$ echo $((2*3-2/2+3))
8
prompt$ NUM=44
prompt$ echo $((NUM*2))
88
prompt$ NUM=$((NUM+1))
prompt$ echo $NUM
45

12


If, for e while
Assim como qualquer outra linguagem de programação, o shell também tem estruturas
para se fazer condicionais e loop. As mais usadas são if, for e while.

if COMANDO for VAR in LISTA while COMANDO
then do do
comandos comandos comandos
else done done
comandos
fi

Diferente de outras linguagens, o if testa um comando e não uma condição. Porém como já
conhecemos qual o comando do shell que testa condições, é só usá-lo em conjunto com o
if. Por exemplo, para saber se uma variável é maior ou menor do que 10 e mostrar uma
mensagem na tela informando:

if test "$VARIAVEL" -gt 10
then
echo "é maior que 10"
else
echo "é menor que 10"
fi

Há um atalho para o test , que é o comando [. Ambos são exatamente o mesmo comando,
porém usar o [ deixa o if mais parecido com o formato tradicional de outras linguagens:

if [ "$VARIAVEL" -gt 10 ]
then
echo "é maior que 10"
else
echo "é menor que 10"
fi

Se usar o [, também é preciso fechá-lo com o ], e sempre devem ter espaços ao
redor. É recomendado evitar esta sintaxe para diminuir suas chances de erro.
Já o while é um laço que é executado enquanto um comando retorna OK. Novamente o
test é bom de ser usado. Por exemplo, para segurar o processamento do script enquanto
um arquivo de lock não é removido:

while test -f /tmp/lock
do
echo "Script travado..."
sleep 1
done

13


E por fim, o for percorre uma lista de palavras, pegando uma por vez:

for numero in um dois três quatro cinco
do
echo "Contando: $numero"
done

Uma ferramenta muito útil para usar com o for é o seq, que gera uma seqüência numérica.
Para fazer o loop andar 10 passos, pode-se fazer:

for passo in $(seq 10)

O mesmo pode ser feito com o while, usando um contador:

i=0
while test $i -le 10
do
i=$((i+1))
echo "Contando: $i"
done

E temos ainda o loop infinito, com condicional de saída usando o "break¨:

while :
do
if test -f /tmp/lock
then
echo "Aguardando liberação do lock..."
sleep 1
else
break
fi
done

14

Exercícios
A melhor parte finalmente chegou, agora é a sua vez de se divertir. Seguem alguns
exercícios que podem ser resolvidos usando o que foi aprendido até aqui.

Alguns exigirão pesquisa e necessitarão de algumas ferramentas que foram apenas
citadas, mas não aprendidas. O shelleiro também tem que aprender a se virar sozinho!

Exercício 1 - relacao.sh

Recebe dois números como parâmetro e mostra a relação entre eles. Exemplo:

prompt$ ./relacao.sh 3 5
3 é menor que 5
5 é maior que 3
5 é igual a 5
prompt$

Exercício 2 - zerador.sh

Recebe um número como parâmetro e o diminui até chegar a zero, mostrando na
tela cada passo, em uma mesma linha. Exemplo:

prompt$ ./zerador.sh 5
5 4 3 2 1 0
prompt$ ./zerador.sh 10
10 9 8 7 6 5 4 3 2 1 0
prompt$

Exercício 3 - substring.sh

Recebe duas palavras como parâmetro e verifica se a primeira palavra está contida
dentro da segunda. Só mostra mensagem informativa em caso de sucesso, do
contrário não mostra nada. Exemplo:

prompt$ ./substring.sh ana banana
ana está contida em banana
prompt$ ./substring.sh banana maria
prompt$ ./substring.sh banana
prompt$ ./substring.sh
prompt$

Pesquise sobre o comando grep

15


Exercício 4 - juntatudo.sh

Mostra na tela "grudados" todos os parâmetros recebidos na linha de comando,
como uma única palavra. Exemplo:

prompt$ ./juntatudo.sh a b c d e f verde azul
abcdefverdeazul
prompt$

Pesquise sobre o comando tr

Exercício 5 - users.sh

Do arquivo /etc/passwd, mostra o usuário e o nome completo de cada usuário do
sistema (campos 1 e 5) separados por um TAB. Exemplo:

prompt$ ./users.sh
ftp FTP User
nobody Nobody
named Domain name server
xfs X Font Server
mysql MySQL server
aurelio Aurelio Marinho Jargas
prompt$

Pesquise sobre o comando cut

Exercício 6 - shells.sh

Do arquivo /etc/passwd, mostra todos os shells (último campo) que os usuários
usam. Não mostrar linhas repetidas. Exemplo:

prompt$ ./shells.sh
/bin/bash
/bin/false
/bin/sync
/sbin/halt
/sbin/shutdown
prompt$

Pesquise sobre o comando uniq

16


Exercício 7 - parametros.sh

Mostra na tela todos os parâmetros recebidos na linha de comando, contando-os.
Exemplo:

prompt$ ./parametros.sh a b c d e f
Parâmetro 1: a
Parâmetro 2: b
Parâmetro 3: c
Parâmetro 4: d
Parâmetro 5: e
Parâmetro 6: f
prompt$

Pesquise sobre o comando shift

17

Mais informações
Livro Programação Shell Linux
Autoria de Julio Cezar Neves, Editora Brasport, ISBN 85-7452-118-3

Livro BASH - Guia de Consulta Rápida
Autoria de Joel Saade, Editora Novatec, ISBN 85-7522-006-3

Lista de discussão nacional sobre Shell Script
http://br.groups.yahoo.com/group/shell-script

Página do instrutor sobre Shell Script, com links para vários outros materiais
http://aurelio.net/shell

18

Respostas dos exercícios
Resista à tentação de olhar as respostas antes de tentar fazer os exercícios! É na prática
que se consolida os conhecimentos aprendidos, não pule este passo. Seja forte, insista,
não desista!

testa-arquivos
#!/bin/bash

echo -n "Digite o arquivo: "
read ARQUIVO

test -d "$ARQUIVO" && echo "$ARQUIVO é um diretório"
test -f "$ARQUIVO" && echo "$ARQUIVO é um arquivo"

test -f "$ARQUIVO" -o -d "$ARQUIVO" || echo "O arquivo '$ARQUIVO' não foi encontrado"

echo

relacao.sh
#!/bin/bash

if test $1 -eq $2
then
echo "$1 é igual a $2"
elif test $1 -lt $2
then
echo "$1 é menor que $2"
else
echo "$1 é maior que $2"
fi

zerador.sh
#!/bin/bash

i=$1
while test $i -ge 0
do
echo -n "$i "
i=$((i-1))
done
echo

19


substring.sh
#!/bin/bash

test $# -ne 2 && exit

echo $2 | grep -qs $1 && echo "$1 está contida em $2"

juntatudo.sh
#!/bin/bash

echo $* | tr -d ' '

users.sh
#!/bin/bash

cat /etc/passwd | cut -d : -f 1,5 | tr : 't'

shells.sh
#!/bin/bash
cat /etc/passwd | cut -d : -f 7 | sort | uniq

parametros.sh
#!/bin/bash

i=0
while test "$1"
do
i=$((i+1))
echo "Parâmetro $i: $1"
shift
done

20

Introdu¸õ
ca
Comandos b´sicos
a
Interpretador de Comandos
Programando em Shell
Atribui¸õ de vari´veis
ca a
Teste de condicional
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Programa¸õ em Shell Script
ca

Kaio Rafael de Souza Barbosa, M.Sc

Universidade Federal do Amazonas - UFAM
E-mail: kaiorafael@dcc.ufam.edu.br

16 de outubro de 2010

Kaio Rafael de Souza Barbosa, M.Sc Programa¸õ em Shell Script
ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Sum´rio
a
1 Introdu¸õ
ca
2 Comandos b´sicos
a
3 Interpretador de Comandos
4 Programando em Shell
5 Atribui¸õ de vari´veis
ca a
Interpola¸õ de vari´veis
ca a
6 Teste de condicional
Case
7 Controles de la¸os
c
Controles de la¸os: while
c
8 Fun¸˜es
co
9 Bˆnus
o
ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Programa¸õ em Shell Scripting
ca

Porque programar em linha de comando se o sistema oferece
ambientes gr´ficos para resolu¸õ de atividades?
a ca

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

ca

Automatiza¸õ de atividades
ca
Administra¸õ de sistemas
ca
Otimizar a execu¸õ de uma aplica¸õ
ca ca
Desenvolver aplicativos

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

ca

O que ´ Programa¸õ em Shell Scripting?
e ca
Um programa em Shell Scripting ´ um conjunto de comandos
e
internos e funcionalidades da linguagem que permitem ao usu´rio
a
desenvolver aplica¸˜es para resolu¸õ de um determinado
co ca
problema.

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Comandos b´sicos
a
A tabela a seguir apresenta os comandos b´sicos para cria¸õ de
a ca
um shell scripting.

Comando Descri¸õ
ca
ls Lista o conte´do de um diret´rio
u o
cd Entra/Muda do diret´rio atual
o
pwd Imprime o nome do diret´rio atual
o
echo Imprime uma linha do terminal
cat Concatena arquivo e imprime uma sa´ ıda
cut Remove se¸˜es de cada linha do arquivo
co
wc Imprime quantas linhas, palavras e bytes tˆm no arquivo
e

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Comandos b´sicos
a

Algumas dicas importantes:
Os comandos sõ sens´
a ıveis em caso de letras mai´scula ou
u
minuscula, isso significa que o comando ls difere do comando
Ls.
´
E poss´ utilizar o resultado de um comando para alimentar
ıvel
um outro como entrada.
Um comando novo pode ser criado a partir da combina¸õ de
ca
dois ou mais comandos.
Quando um comando ´ executado com sucesso, nenhuma
e
mensagem ´ apresentada **
e

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Comandos b´sicos
a

Exemplo: Saber a localiza¸˜o atual do usu´rio.
ca a

$ pwd
/home/erin

Exemplo: Quantas linhas possuem o arquivo /etc/passwd.

$ cat /etc/passwd | wc -l
44

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o


O interpretador de comandos analisa e processa os comandos que
sõ enviados ao sistema operacional. Por exemplo, o comando ls
a
acessa `s chamadas de sistema (system calls) para manipula¸õ de
a ca
entrada e sa´
ıda.

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

A Figura abaixo ilustra a arquitetura de um sistema de
computador.

Figura: Shell em uma arquitetura de um sistema de computador.

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o


Para atender diferente usu´rios do sistema, existem varia¸˜es de
a co
Shells dispon´
ıveis no Linux. O arquivo /etc/shells indica quais
interpretadores de comando estõ instalados.
a

Shell Descri¸õ
ca
bash Shell moderno do Linux, baseado no antigo Bourn Shell (sh)
ksh Korn Shell estende todas as funcionalidades do sh
tcsh Shell que incorpora elementos da linguagem de programa¸õ C
ca
zsh Shell que incorpora recursos do bash, tcsh e ksh

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

A lista de interpretadores instalados no sistema pode ser
identiﬁcada pela leitura do arquivo /etc/shells. Segue o
exemplo:
$ cat /etc/shells
/bin/csh
/bin/sh
/usr/bin/es
/usr/bin/ksh
/bin/ksh
/usr/bin/rc
/usr/bin/tcsh
/bin/tcsh
/bin/bash
ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o


Ferramentas para desenvolver os scripts:
Shell
Editor de textos favoritos

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o


Figura: C´digo fonte do programa ”Ol´ Mundo”.
o a
ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Invocando um script

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a Interpola¸õ de vari´veis
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

ca a

Uma vari´vel ´ uma sequˆncia de caracteres dos quais ´ poss´
a e e e ıvel
atribuir valores. A declara¸õ de uma vari´vel no Shell ´
ca a e
identificada quando o sinal de igualdade (=) ´ encontrado. O
e
exemplo a seguir declara duas vari´veis, CURSO e ALUNO, e imprime
a
seu conte´do.
u

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

ca a

Exemplo:

$ cat -n variaveis.sh
1 #!/bin/bash
2
3 CURSO="Programacao em Shell Scripting"
4 ALUNO="erin"
5
6 echo "$ALUNO, voce esta no curso de: $CURSO"

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

ca a

A execu¸˜o do script variaveis.sh est´ descrita abaixo.
ca a

$ bash variaveis.sh
erin, voce esta no curso de: Programacao em Shell Scripting

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

ca a

A interpola¸õ de vari´veis avalia como ser´ a substitui¸õ da
ca a a ca
vari´vel. Por exemplo, ao utilizar echo $ALUNO o conte´do da
a u
vari´vel ALUNO foi impresso.
a

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

ca a
´
E importante observar com cuidado alguns caso de interpola¸õ de
ca
vari´veis.
a
Aspas dupla - Quando um caractere especial ´ observado
e
entre aspas dupla, o Shell ignora seu significado, com exce¸õ
ca
do cifrõ ($), crase ( ` ), barra invertida ().
a
Aspas simples - Quando um caractere especial ´ observado
e
entre aspas simples, o Shell ignora seu significado, sem
exce¸õ.
ca
Crase - Utilizando quando ´ necess´rio executar um comando
e a
do sistema. Este tipo de substitui¸õ tamb´m ´ chamada
ca e e
substitui¸õ de comando.
ca
ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

ca a

Exemplo:
$ cat -n variaveis2.sh
1 #!/bin/bash
2
3 COMANDO=$(ls /etc | wc -l)
4 USUARIO="Erin"
5
6 echo "$USUARIO, existem $COMANDO diretorios no /etc"

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a Case
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o


O condicional se (if) avalia se uma condi¸õ ´ verdadeira ou falsa.
ca e
Em termos gerais, a expressõ if pode ser expressa da seguinte
a
forma:

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a Case
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o


if [ TESTE-CONDICIONAL ]
then
COMANDOS
fi

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a Case
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o


Exemplo:
$ cat -n condicionalif.sh
1 #!/bin/bash
2
3 VALOR1=10
4 VALOR2=10
5
6 if [ $VALOR1 -eq $VALOR2 ]
7 then
8 echo "O valor: $VALOR1 e’ igual ao valor: $VALOR2"
9 fi

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a Case
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o


O Shell possui alguns recursos interessantes para avalia¸õ de
ca
condicionais. Por exemplo, ´ poss´ testar se um arquivo ou um
e ıvel
diret´rio existe, se o usu´rio tem acesso de leitura no arquivo ou se
o a
o arquivo ´ uma liga¸õ (link) simb´lica.
e ca o

Expressõ
a Significado
[ -a Arquivo ] Avalia se o arquivo existe
[ -b Arquivo ] Avalia se o arquivo existe e ´ um arquivo de bloco
e
[ -w Arquivo ] Avalia se o arquivo existe e possui permissõ de escrita
a
[ -x Arquivo ] Avalia se o arquivo existe e possui permissõ de execu¸õ
a ca
[ Arq1 -nt Arq2 ] Avalia se o arquivo (Arq1) ´ mais recente que Arq2
e

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a Case
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o


No caso de compara¸õ de strings ´ necess´rio utilizar outros
ca e a
operadores. Por exemplo, o c´digo abaixo ilustra a compara¸õ
o ca
entre dois strings.
$ cat -n condicionalif2.sh
1 #!/bin/bash
2
3 NOME1="Erin"
4 NOME2="ERIn"
5
6 if [ $NOME1 == $NOME2 ]
7 then
8 echo "Strings iguais..."
9 fi

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a Case
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

O Shell estende o if caso o resultado nõ seja verdade. Em outras
a
palavras, ´ poss´ avaliar condi¸˜es com if-else. O exemplo abaixo
e ıvel co
ilustra um teste condicional quando o resultado nõ ´ verdadeiro.
a e
cat -n condicionalif.sh
1 #!/bin/bash
2
3 NOME1="Erin"
4 NOME2="ERIn"
5
6 if [ $NOME1 == $NOME2 ]
7 then
8 echo "Strings iguais..."
9 else
10 echo "String sao diferentes"
11 fi

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a Case
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Teste de condicional: case

O comando case ´ utilizado para deixar o c´digo mais leg´
e o ıvel, pois,
o excesso de condicionais if prejudicam o entendimento do c´digo.
o
O exemplo abaixo ilustra o emprego do comando case.

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a Case
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Teste de condicional: case

$ cat -n condicionalcase.sh
1 #!/bin/bash
2 VALOR=4
5 case $VALOR in
6 1)
7 echo "Valor igual a 1" ;;
8 2)
10 3)
12 4)
13 echo "Valor igual a 4";;
14 *)
15 echo "Nao achei o valor";;
16 esac

ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a Controles de la¸os: while
c
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Controles de la¸os: for
c

Os controladores de la¸os em Shell sõ utilizados para realizar
c a
atividades repetitivas. Por exemplo, ´ poss´ combinar o la¸o for
e ıvel c
no terminal para criar uma sequˆncia de arquivos vazios. O c´digo
e o
abaixo ilustra essa situa¸õ.
ca

$ for VAR in $(seq 0 9); do touch arquivo_$VAR; done
$ ls
arquivo_0 arquivo_2 arquivo_4 arquivo_6 arquivo_8
arquivo_1 arquivo_3 arquivo_5 arquivo_7 arquivo_9

ca

Introdu¸˜o
ca
Comandos b´sicos
a
c
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Controles de la¸os: for
c

O que ser´ impresso no terminal?
a

$ cat -n lacofor.sh
1 #!/bin/bash
2
3 for INDICE in laranja maca pera uva
4 do
5 echo "Quando custa: $INDICE ?"
6 done

ca

Introdu¸˜o
ca
Comandos b´sicos
a
c
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

c

O comando de la¸o while ´ executado at´ que uma condi¸˜o seja
c e e ca
´
realizada. E um dos comandos de controle de la¸os mais simples
c
de ser empregado no Shell. Sua sintaxe pode ser denotada da
seguinte forma.

ca

Introdu¸˜o
ca
Comandos b´sicos
a
c
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

c

Sintaxe do while:

while [ condi¸~o ]
ca
do
comandos
done

ca

Introdu¸˜o
ca
Comandos b´sicos
a
c
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

c
Exemplo:
$ cat -n lacowhile.sh
1 #!/bin/bash
2
3 SAIDA=10
4 CONTADOR=0
5
6 while [ $CONTADOR -lt $SAIDA ]
7 do
8 echo "Atividades de sala aula"
9 CONTADOR=$(( $CONTADOR + 1 ))
10 done
ca

Introdu¸õ
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Fun¸oes
c˜

Fun¸˜es sõ empregadas para organizar a estrutura do c´digo ou
co a o
realizar determinada opera¸õ ainda nõ dispon´ no sistema.
ca a ıvel
Por exemplo, uma fun¸õ que leia o nome e a data de um filme
ca
que foi assistido e armazene esses dados um arquivo texto.

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Fun¸oes
c˜

Uma fun¸˜o pode ser declarada da seguinte maneira:
ca

nome_da_funcao () {
comandos
}

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Fun¸oes
c˜

validaIdade() {
ARG1=$1 # primeiro argumento
ARG2=$2 # segundo argumento

if [ $ARG2 -gt $IDADE ]
then
echo "Ola $ARG1, voce possui a maior idade"
fi
}

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Fun¸oes
c˜
1 #!/bin/bash
2 RESPOSTA1=""
4 RESPOSTA2=""
5 IDADE=18
6 CONTADOR=0
7 SAIDA=5
8 validaIdade() {
11 ARG1=$1
12 ARG2=$2
13 if [ $ARG2 -gt $IDADE ]; then
16 echo "Ola $ARG1, voce possui a maior idade"
17 fi
18 }
19 # Codigo Principal
20 while [ $CONTADOR -lt $SAIDA ]
21 do
22 echo "Qual seu nome?"
23 read RESPOSTA1
24 echo "Quantos anos voce tem?"
25 read RESPOSTA2
26 echo $RESPOSTA2
27 validaIdade $RESPOSTA1 $RESPOSTA2
28 CONTADOR=$(( $CONTADOR + 1 ))
29 done
ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Array: Vetores

1 #!/bin/bash
2
3 ARRAY=("LARANJA" "PERA" "UVA" "CARRO")
4
5 echo "Sua sacola possui"
6 for I in ${ARRAY[@]}
7 do
8 echo "$I"
9 done

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Express˜es regulares
o

sed
awk
xargs

ca

Introdu¸˜o
ca
Comandos b´sicos
a
ca a
Controles de la¸os
c
Fun¸˜es
co
Bˆnus
o

Express˜es regulares
o

$ for I in $(cat /etc/passwd | cut -f 1 -d:) ; do echo "ola $I" ; done

ca

Operadores Variáveis especiais Blocos e agrupamentos
Operadores Aritméticos Operadores Relacionais Variável Parâmetros Posicionais Sintaxe Descrição Exemplo
+ Adição == Igual $0 Parâmetro número 0 (nome do comando ou função) "..." Protege uma string, mas reconhece $, e ` como especiais "abc"
- Subtração != Diferente $1 Parâmetro número 1 (da linha de comando ou função) '...' Protege uma string, nenhum caractere é especial 'abc'
* Multiplicação > Maior ... Parâmetro número N ... $'...' Protege uma string, mas interpreta n, t, a, etc $'abcn'
/ Divisão >= Maior ou Igual $9 Parâmetro número 9 (da linha de comando ou função) `...` Executa comandos numa subshell, retornando o resultado `ls`
% Módulo < Menor ${10} Parâmetro número 10 (da linha de comando ou função) {...} Agrupa comandos em um bloco { ls ; }
** Exponenciação <= Menor ou Igual ... Parâmetro número NN ... (...) Executa comandos numa subshell ( ls )
Operadores de Atribuição Operadores de BIT $# Número total de parâmetros da linha de comando ou função $(...) Executa comandos numa subshell, retornando o resultado $( ls )
= Atribui valor a uma variável << Deslocamento à esquerda $* Todos os parâmetros, como uma string única ((...)) Testa uma operação aritmética, retornando 0 ou 1 ((5 > 3))
+= Incrementa a variável por uma constante >> Deslocamento à direita $@ Todos os parâmetros, como várias strings protegidas $((...)) Retorna o resultado de uma operação aritmética $((5+3))
-= Decrementa a variável por uma constante & E de bit (AND) Variável Miscelânia [...] Testa uma expressão, retornando 0 ou 1 (alias do comando 'test') [ 5 -gt 3 ]
*= Multiplica a variável por uma constante | OU de bit (OR) $$ Número PID do processo atual (do próprio script) [[...]] Testa uma expressão, retornando 0 ou 1 (podendo usar && e ||) [[ 5 > 3 ]]
/= Divide a variável por uma constante ^ OU exclusivo de bit (XOR) $! Número PID do último job em segundo plano
%= Resto da divisão por uma constante ~ Negação de bit $_ Último argumento do último comando executado Opções do comando test ou [
++ Incrementa em 1 o valor da variável ! NÃO de bit (NOT) $? Código de retorno do último comando executado Testes em arquivos Testes em variáveis
-- Decrementa em 1 o valor da variável -b É um dispositivo de bloco
Operadores Lógicos Operadores de BIT (atribuição) Expansão de variáveis -c É um dispositivo de caractere Comparação Numérica
&& E lógico (AND) <<= Deslocamento à esquerda Sintaxe Expansão Condicional -d É um diretório -lt É menor que (LessThan)
|| OU lógico (OR) >>= Deslocamento à direita ${var:-texto} Se var não está definida, retorna 'texto' -e O arquivo existe -gt É maior que (GreaterThan)
&= E de bit ${var:=texto} Se var não está definida, defina-a com 'texto' -f É um arquivo normal -le É menor igual (LessEqual)
|= OU de bit ${var:?texto} Se var não está definida, retorna o erro 'texto' -g O bit SGID está ativado -ge É maior igual (GreaterEqual)
^= OU exclusivo de bit ${var:+texto} Se var está definida, retorna 'texto', senão retorna o vazio -G O grupo do arquivo é o do usuário atual -eq É igual (EQual)
Sintaxe Expansão de Strings -k O sticky-bit está ativado -ne É diferente (NotEqual)
Redirecionamento ${var} É o mesmo que $var, porém não ambíguo -L O arquivo é um link simbólico
-O O dono do arquivo é o usuário atual Comparação de Strings
Operador Ação ${#var} Retorna o tamanho da string
-p O arquivo é um named pipe = É igual
< Redireciona a entrada padrão (STDIN) ${!var} Executa o conteúdo de $var (igual 'eval $$var')
-r O arquivo tem permissão de leitura != É diferente
> Redireciona a saída padrão (STDOUT) ${!texto*} Retorna os nomes de variáveis começadas por 'texto'
-s O tamanho do arquivo é maior que zero -n É não nula
2> Redireciona a saída de erro (STDERR) ${var:N} Retorna o texto à partir da posição 'N'
-S O arquivo é um socket -z É nula
>> Redireciona a saída padrão, anexando ${var:N:tam} Retorna 'tam' caracteres à partir da posição 'N'
-t O descritor de arquivos N é um terminal
2>> Redireciona a saída de erro, anexando ${var#texto} Corta 'texto' do início da string
-u O bit SUID está ativado Operadores Lógicos
| Conecta a saída padrão com a entrada padrão de outro comando ${var##texto} Corta 'texto' do início da string (* guloso)
-w O arquivo tem permissão de escrita ! NÃO lógico (NOT)
2>&1 Conecta a saída de erro na saída padrão ${var%texto} Corta 'texto' do final da string
-x O arquivo tem permissão de execução -a E lógico (AND)
>&2 Conecta a saída padrão na saída de erro ${var%%texto} Corta 'texto' do final da string (* guloso)
-nt O arquivo é mais recente (NewerThan) -o OU lógico (OR)
>&- Fecha a saída padrão ${var/texto/novo} Substitui 'texto' por 'novo', uma vez
-ot O arquivo é mais antigo (OlderThan)
2>&- Fecha a saída de erro ${var//texto/novo} Substitui 'texto' por 'novo', sempre
-ef O arquivo é o mesmo (EqualFile)
3<>arq Conecta o descritor de arquivos 3 ao arquivo 'arq' ${var/#texto/novo} Se a string começar com 'texto', substitui 'texto' por 'novo'
<<FIM Alimenta a entrada padrão (Here Document) ${var/%texto/novo} Se a string terminar com 'texto', substitui 'texto' por 'novo'
<<-FIM Alimenta a entrada padrão, cortando TABs
<(cmd) A saída do comando 'cmd' é um arquivo: diff <(cmd1) <(cmd2)
>(cmd) A entrada do comando 'cmd' é um arquivo: tar cf >(bzip2 -c >file.tbz) $dir

Canivete Suíço do Shell (bash) — Aurélio Marinho Jargas | www.aurelio.net | @oreio

Introdução ao Shell Script: Comandos básicos

Introdução ao Shell Script: Comandos básicos

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Introdução ao Shell Script: Comandos básicos

Semelhante a Introdução ao Shell Script: Comandos básicos (20)

Mais de Eduardo de Lucena Falcão

Mais de Eduardo de Lucena Falcão (20)

Introdução ao Shell Script: Comandos básicos