Programação em shell

4 Comandos básicos bash

Programação em Shell LDP, manuais para usuários
manuais UNIX e Linux

4 Programação em shell
Matthew & Stones cap 2
Taisy Weber • pipe,
• redirecionamento de entrada e de saída,
• comandos,
• variáveis, estruturas de controle e condicionais
• criação de scripts
TSW 2

Apoio bibliográfico Shell

Siever, E. Linux in a Nutsell. O’Reilly
– comandos: preferencialmente man, info e LDP 4 processador de comandos reuso de código
– programação em shell 4 linguagem de programação (interpretador)
• Matthew, N; Stones, R. "Beginning Linux
• adequada para prototipação
Programming", Wrox press, 1999 (2th Edition) -
capítulo 2 • programação rápida e simples
» conferir programas e scripts em: • ideal para pequenos utilitários
http://www.wrox.com • fácil manutenção, configuração
cópia no servidor gaea.inf.ufrgs.br pasta ProgLinux • grande portabilidade mas os programas não
• Ball, B. Usando Linux. Campus são muito eficientes
Capítulo 22. Rápida introdução. Adequado para quem não
domina o inglês.
4 controle de tarefas
TSW 3 TSW 4

Várias shells bash

4 UNIX permite vários programas shell – POSIX-compatível
lab
• o usuário escolhe um de sua preferência • shell deve estar instalada em /bin/sh
– verificar com comando ls -l /bin/sh
– mais comuns
• sh (Bourne) shell original do UNIX – comandos bash
• csh, tcsh e zsh C shell (Bill Joy) • antes de entrarmos em programação shell é
necessário conhecer os comandos básicos da shell
• ksh, pdksh Korn shell (David Korn)
• bash Bourne Again Shell Comandos Linux e MS-DOS guardam alguma
semelhança. Partes do MS-DOS foram inspiradas no
muito popular em Linux CP/M, que por sua vez foi inspirado no UNIX.
existe um grande número de outras shells
COMMAND.COM shell única do DOS
características são mais ou menos comuns
TSW 5 TSW 6

1
 Comandos UNIX Resumo de alguns comandos
não tenha medo de experimentar!
revisar
– se você não possui domínio dos comandos
cat: lê e mostra arquivos em stout, se não aparece arquivo então stin,
básicos UNIX, está na hora de: permite concatenação
– explorar os comandos UNIX (Linux)
grep: pesquisa em um ou mais arquivos por linhas que casam com uma
– estabelecer uma relação entre os comandos básicos e o expressão regular dada ( -l: listar)
MS-DOS
– familiarizar-se com os conceitos elementares de operação ls: lista conteúdo de um diretório dado, se nenhum é dado lista o atual
de ambientes UNIX more: display o conteúdo do arquivo, uma tela de cada vez
– aprender a usar redirecionamento e pipes
chmod: altera as permissões de acesso de um arquivo
• exercite-os listando arquivos diretórios, verificando
o estado de processos ... touch : verifica se existe arquivo, senão cria
use man rm : remove arquivo use man
lab lab
TSW 7 TSW 8

Redirecionamento Redirecionamento (>) de stout

4 entrada e saída padrão – exemplo simples:
redireciona saída
– stdin entrada padrão
$ ls -l > lssaida.txt
também stin e stout
– stdout saída padrão salva a saída do comando ls no arquivo lssaida.txt
– entrada e saída padrão e descritores de arquivo ls : lista o conteúdo de um diretório dado; se nenhum
– stdin - file descritor 0 diretório é dado, lista o diretório atual
– stout - file descritor 1
– st error out - file descritor 2 – CUIDADO!!!
– redirecionamento • o redirecionamento escreve sobre o arquivo (se o
• troca um arquivo padrão por outro arquivo indicado arquivo já existe) apagando o conteúdo anterior

TSW 9 TSW 10

Usando cat e > Append >>

cat: lê e mostra arquivos em stout;
permite contatenação
– comando cat 4 >> (append)
$ cat rel.txt > novorel.txt – anexa a saída ao fim de um arquivo
$ cat rel1 rel2 rel3> novorel.txt • evita apagar um arquivo que já existe como em >
• entrada rápida de texto • também existe << (raro uso)
exemplo: Ball, B.
$ cat > novorel.txt Usando Linux. pg 21
>isso é uma linha de texto
>isso é mais uma linha de texto
>[EOF]
digite Crt+D para marca de fim de arquivo
• para mostrar o resultado
$ cat novorel.txt
lab
TSW 11 TSW 12

2
 Redirecionamento operador 2>
da saída de erro
– usar > com o número do descritor de arquivo – 2> exemplo : arquivo rel.txt não existe
• operador 2>
$ cat rel.txt >novorel.txt
• útil para descartar informação de erro, evitando que cat: rel.txt: No such file or diretory
apareça na tela
redirecionamento de stout mens. erro
• exemplo: vai para $ cat rel.txt >novorel.txt 2>erros.log
$ kill -HUP 1234 > killout.txt 2>killerr.txt erros.log $ cat erros.log
cat: rel.txt: No such file or diretory
redirecionamento de saída de erro
Matando um processo de um script: existe o risco do $ cat rel.txt >novorel.txt 2>/dev/null
processo já estar morto. Redirecionar as mensagens de
erro evita que elas apareçam na tela. balde furado universal: /dev/null
lab
TSW 13 TSW 14

Redirecionamento (<) de stin Pipe

canal
– arquivos de entrada também podem ser 4 processos rodam em pipeline
redirecionados • saída de um processo é a entrada do outro
– Ex: – operador |:
exemplo bobo exemplo: ordenar saída de ps
$ ps > psout.txt ps: processor status
$ more < killout.txt $ sort psout.txt > pssort.out

mais elegante em uma só linha usando pipe

more: mostra na tela o conteúdo do arquivo,
$ ps | sort pssort.out
uma tela de cada vez
pipe com 3 comandos: mostra status de processos ordenados na tela
$ ps | sort | more
TSW 15 TSW 16

Expansão de wildcard curinga

Shell como linguagem
duas formas
a Shell expande wildcards
4 revisar: 4 escrevendo programas em Shell
–* qualquer caracter (0 ou mais caracteres) forma 1– digitando os comandos e executando-os

–? um único caracter interativamente

– o prompt normal $ troca para > quando se inicia a digitar
– [set] conjunto específico de caracteres simples comandos na Shell
– [^set] – a seguir o programa é executado

– {string} agrupa strings que serão expandidos pela Shell forma 2– armazenando os comandos em um arquivo e
exemplo: invocando da mesma forma que um programa
$ ls my_{finger,toe}s $ ls my_fingers – usando um editor de textos comum
scripts
$ ls my_toes
TSW 17 TSW 18

3
 Exemplo de programa interativo Programa interativo x script
primeira forma
– determinar todos os arquivos que contém o 4 programa interativo
string POSIX – desvantagem primeira forma
arquivo é uma variável e
$ for arquivo in * $arquivo seu conteúdo • digitar o programa cada vez que for necessário
> do
> if grep -l POSIX $arquivo • inibe reuso
> then
> more $arquivo
4 shell script segunda forma
> fi • armazenar programa em um arquivo
> done grep e more são comandos
• invocar o arquivo
grep: pesquisa em um ou mais arquivos por linhas que
casam com uma expressão regular dada ( -l: listar)
– vantagem
more: mostra o conteúdo do arquivo, uma tela de cada vez
• scripts possibilitam reuso
TSW 19 TSW 20

Exemplo de shell script Executando scripts

4 arquivo chamado
primeiro.sh
– .sh sem significado
– # indica comentário
– #! comentário especial
• indica qual programa deve
ser usado para executar o
arquivo
• /bin/sh =shell default
– exit 0
• código de retorno
• 0 indica sucesso
#!/bin/sh
# primeiro.sh – forma fácil
# compilar apenas os arqs. • invocar a shell com o nome do arquivo
# contendo string POSIX $ /bin/sh primeiro.sh
for file in * – forma mais elegante
do chmod: altera as permissões
if grep -l POSIX $file • invocar diretamente de acesso de um arquivo
$ chmod +x primeiro.sh +x: adiciona modo executável
then
$ primeiro.sh
more $file
fi • pode não funcionar
done
– o arquivo pode não ser localizado (se PATH não foi
exit 0 atualizada para procurar no diretório atual)

TSW 21 TSW 22

Variáveis read
shell sintax
– não são usualmente declaradas antes de usar – read permite ler do teclado valor de variável
– criadas quando usadas pela primeira vez • termina pressionando tecla de return
– maiúsculas e minúsculas são diferenciadas
– valor de uma variável: $ antes do nome #!/bin/sh
mostra conteúdo
$ meuscumprimentos=Alo echo Entre algum texto da variável
$ echo $meuscumprimentos precisa de apóstrofes read texto
$texto
Alo se contém espaços echo $texto
$ meuscumprimentos= ”Tudo bem” echo '$texto' agora contém $texto
$ echo $meuscumprimentos
Tudo bem
$ meuscumprimentos=9+3 mostra o string $texto
$ echo $meuscumprimentos
9+3
lab lab
TSW 23 TSW 24

4
 Apóstrofes na shell Variáveis de ambiente
para conter
#!/bin/sh
4 pequena pausa para falar espaços
sobre apóstrofes simples e
4 são variáveis pré-definidas
myvar="Hi there"
duplas – valores são obtidos do sistema quando um
echo $myvar
echo "$myvar"
script inicia execução
mostra string $myvar mostra valor • dependem do ambiente de execução
echo '$myvar' da variável
echo \$myvar • normalmente maiúsculas
– para distinguir das variáveis do usuário (geralmente
\ remove qualquer echo Enter some text minúsculas)
significado especial read myvar
• dependem da configuração particular do ambiente
de $
echo '$myvar' now equals $myvar

exit 0
exemplos: $HOME, $PATH, $#, $$
lab
TSW 25 TSW 26

Mais algumas
Algumas variáveis de ambiente variáveis de ambiente
– $HOME – $PS1
• diretório pessoal (home) do usuário atual • command prompt (usualmente $)
– $PATH – $PS2
• lista de diretórios onde procurar por comandos • command prompt secundário (usualmente >)
– separado por : (dois pontos) – $IFS
/usr/local/bin:/bin:/usr/bin:.:/home/neil/bin
exemplo • separador de campos de entrada
• usualmente
– $# número de parâmetros passados
– espaço
– $$ o process ID da shell script – tab
– nova linha
TSW 27 TSW 28

Parâmetros Exemplo
salvar o arquivo com o nome #!/bin/sh
– variáveis adicionais são criadas quando a shell de tentar_var salutation="Hello"
é invocada com parâmetros echo $salutation
não esquecer echo "The program $0 is now running"
• se a shell for invocada sem parâmetros então chmod +x tentar_var echo "The second parameter was $2"
$# possui o valor 0 (zero) echo "The first parameter was $1"
echo "The parameter list was $*"
• $1, $2, ... parâmetros dados ao script echo "The user's home dir is $HOME"
• $* lista de todos os parâmetros echo "Please enter a new greeting"
read salutation
separados pelo 1o. caracter em IFS echo $salutation
• $@ variação de $* que não usa IFS o que acontece? echo "The script is now complete"
exit 0
executar
IFS: separador de campos de entrada $ ./tentar_var foo bar baz

lab
TSW 29 TSW 30

5
 Teste de condições
4 comando de teste
– duas formas equivalentes
[ ] não esquecer dos espaços
test
– condições de teste
• 3 categorias
– comparação de strings
– comparação aritmética
– características de arquivos
Comparação de strings
Comparação Verdadeiro se:
string1 = string2 São iguais
string1 != string2 Não são iguais
exemplos serão vistos -n string String não é nulo
junto a estruturas de
controle -z string String é null (string vazio)

TSW 31 TSW 32

Comparação aritmética Características de arquivos

verdadeiro se verdadeiro se
Comparação Verdadeiro se:
-d file É diretório -s file Tamanho não é
expr1 -eq expr2 São iguais zero
expr1 -ne expr2 Não são iguais -e file Existe -u file set-user-id
expr1 -gt expr2 expr1 > expr2 está ligado
expr1 -ge expr2 expr1 >= expr2 -f file É arquivo -w file Pode ser escrito
expr1 -lt expr2 expr1 < expr2 regular
expr1 -le expr2 expr1 <= expr2 -g file set-group- -x file É executável
! expr Not expr id está ligado
-e e -f são similares
-r file É legível -f é mais usada
TSW 33 TSW 34

Estruturas de controle if
if condition
then
4 if teste de condição
statements #!/bin/sh
else
4 elif para else statements echo "Is it morning? yes or no"
for variable in values fi read timeofday teste: observe espaços
do
4 for statements
done while condition; do
if [ $timeofday = "yes" ]; then
echo "Good morning"
statements
4 while done
else
problema se entrar algo
echo "Good afternoon"
until condition; do diferente de yes ou no
4 until statements
fi
done pode ser resolvido com mais
case variable in exit 0 um teste no ramo else
4 case pattern [ | pattern] ...) statements;;
pattern [ | pattern] ...) statements;;
esac lab
TSW 35 TSW 36

6
 elif problema??? entrando com return
#!/bin/sh

echo "Is it morning? Please answer yes or no"

– problema com o if if [ $timeofday = "yes" ]

read timeofday • timeofday será considerado como:

if [ $timeofday = "yes" ] if [ = "yes" ] condição inválida
then gera mensagem de erro
echo "Good morning" segundo teste
elif [ $timeofday = "no" ]; then
echo "Good afternoon" – para evitar esse problema
else
echo "Sorry, $timeofday not recognized. Enter yes or no" • usar apóstrofes
exit 1 if [ "$timeofday" = "yes" ]
fi
script termina com valor 1 • timeofday será considerado como:
exit 0
if ["" = "yes" ]
ainda tem um problema se entra return condição válida
lab
TSW 37 TSW 38

elif & if & teste com apóstrofes for for variable in values
do
#!/bin/sh statements
#!/bin/sh done
echo "Is it morning? Please answer yes or no" for foo in bar fud 43
lista de valores bar fud 43
read timeofday do
apóstrofes echo $foo
if [ "$timeofday" = "yes" ] done
then
exit 0 $(comand)
echo "Good morning"
elif [ "$timeofday" = "no" ]; then #!/bin/sh fornece a lista para o for
echo "Good afternoon"
else for file in $(ls f*.sh); do
echo "Sorry, $timeofday not recognized." echo $file
echo "Enter yes or no"
done
exit 1
fi exit 0

exit 0
lab lab
TSW 39 TSW 40

while while condition; do

until until condition; do
statements statements
#!/bin/sh done pipe done
#!/bin/sh

echo "Enter password" until who | grep "$1" > /dev/null

read trythis do
while [ "$trythis" != "secret" ]; do sleep 60 loop até usuário com login dado pelo
echo "Sorry, try again" done parâmetro $1 logar-se na máquina
read trythis
done #!/bin/sh # Now ring the bell
exit 0 # and announce the expected user
foo=1
while [ "$foo" -le 20 ] echo -e \\a toca o alarme
do echo "*** $1 has just logged in ***"
apóstrofes desnecessárias echo "Here we go again"
foo=$(($foo+1)) exit 0
done
$(( ))
exit 0
lab
TSW 41 TSW 42

7
 case case variable in
pattern [ | pattern] ...) statements;;
case
pattern [ | pattern] ...) statements;;
esac forma mais curta: agrupando alguns ramos
#!/bin/sh #!/bin/sh

echo "Is it morning? Please answer yes or no" echo "Is it morning? Please answer yes or no"
read timeofday read timeofday

executa o primeiro comando que casa e finaliza case "$timeofday" in

case "$timeofday" in yes | y | Yes | YES ) echo "Good Morning";;
n* | N* ) echo "Good Afternoon";;
"yes") echo "Good Morning";;
* ) echo "Answer not recognised";;
"no" ) echo "Good Afternoon";; esac
"y" ) echo "Good Morning";;
"n" ) echo "Good Afternoon";; exit 0 exemplo do uso de * em case
* ) echo "Sorry, answer not recognised";;
esac expansão do wildcard * em N* e n* pode casar com
exit 0 bom aparecer sempre no fim um grande número de palavras, não apenas NO e no

TSW 43 TSW 44

case Listas de comandos

outra variação
#!/bin/sh

echo "Is it morning? Please answer yes or no" 4 permite executar uma série de comandos
read timeofday
case "$timeofday" in – lista E (AND list)
yes | y | Yes | YES )
echo "Good Morning" • executa o próximo comando apenas se todos os
set echo "Up bright and early this morning?" anteriores executam com sucesso
;;
[nN]* ) • executa enquanto comando retorna TRUE
echo "Good Afternoon"
;; – lista OU (OR list)
* )
echo "Sorry, answer not recognised" • executa o próximo comando apenas se todos os
echo "Please answer yes or no"
exit 1
anteriores executam sem sucesso
;; saída com código 1 • executa enquanto comando retorna FALSE
esac
exit 0
TSW 45 TSW 46

Lista E Lista OU
statement1 && statement2 && statement3 && .. statement1 || statement2 || statement3 || ..

#!/bin/sh #!/bin/sh
teste retorna FALSE
touch f_one teste retorna FALSE rm -f f_one
rm -f f_two
if [ -f f_one ] || echo "hello" || echo "there"
if [ -f f_one ] && echo "hello" && [ -f f_two ] && echo "there" then
then echo -e "in if" executa não executa
echo -e "in if" else
não executa
else echo -e "in else"
echo -e "in else" fi
fi ramo else é executado porque exit 0 ramo then é executado porque
exit 0 condition é FALSE (terceiro condition é TRUE (segundo
comando da lista AND) comando da lista OR)
rm : remove arquivo
touch : verifica se arquivo
existe, senão cria
rm : remove arquivo
lab lab
TSW 47 TSW 48

8
 Listas E e OU Blocos de comandos
– listas E e OU retornam valor do último 4 usar { }
comando avaliado • permitem construir um bloco de comandos
• lista E: geralmente falso (a menos que todos os – blocos são usados para colocar múltiplos
comandos da lista retornem verdadeiro)
comandos onde apenas um comando é
• lista OU: geralmente verdadeiro (a menos que todos
permitido
os comandos da lista retornem falso)
{
– listas E e OU podem ser combinadas statement
• exercício para especialistas em lógica statement
statement
exemplo: [ -f .profile ] && exit 0 || exit 1
}

TSW 49 TSW 50

Funções Função: exemplo

4 facilitam a escrita de programas grandes #!/bin/sh
declarar antes de usar
– mesma argumentação usada para linguagens de foo() {
programação echo "Function foo is executing"
}
• alternativa seria chamar programas dentro de
programas echo "script starting"
foo
• funções são mais rápidas e a passagem de chamada da função
echo "script ended"
parâmetros é mais simples
exit 0
4 definição function-name () {
statements
}
lab
TSW 51 TSW 52

Parâmetros $1, $2, ... parâmetros dados ao script

Função: mais um exemplo ...
$* lista de todos os parâmetros fonte: my_name
definição da função
4 passagem de parâmetros #!/bin/sh
• quando uma função é invocada, os parâmetros
yes_or_no() {
posicionais são substituídos pelos parâmetros da echo "Is your name $* ?"
função while true
do
• quando a função termina, os parâmetros posicionais echo -n "Enter yes or no: " retorno de valor numérico
são restaurados ao valor inicial read x 0 equivale a verdadeiro
case "$x" in
4 comando return y | yes ) return 0;;
1 equivale a falso
n | no ) return 1;;
– forma da função retornar valores * ) echo "Answer yes or no"
esac
• retorna valores numéricos done
} lab
TSW 53 TSW 54

9
 Função: mais um exemplo Comandos
fonte: my_name

echo "Original parameters are $*" lista de todos parâmetros 4 normais qualquer comando UNIX válido

if yes_or_no "$1" • comandos que podem ser executados a partir do

chamada de função com
then passagem de um parâmetro prompt da shell, não apenas dentro de um script
echo "Hi $1, nice name"
else 4 internos (built-in)
echo "Never mind"
fi
teste de valor numérico • comandos que só podem ser executados dentro de
0 verdadeiro um script
exit 0 1 falso
• não podem ser invocados externamente
programa principal com invocação da função – para alguns deles existem programas externos
correspondentes
executar com $./my_name.sh Taisy Weber – os internos são mais eficientes
lab
TSW 55 TSW 56

Alguns comandos Execução de comandos

evitar forma antiga‘command’
4 break 4 export 4 $(command)
ver $(( ))
4: 4 expr – captura o resultado da execução de um
gera saída comando e permite colocar em uma variável
4 continue 4 printf
formatada, só
4. 4 return disponível • resultado é uma string (saída do comando)
mostra um string
recentemente • resultado não é estado de retorno
4 echo 4 set
#!/bin/sh
4 eval 4 shift
echo diretorio atual e’ $PSW
4 exec 4 trap echo usuario atual é $(wo)
4 exit n 4 unset exit 0 PSW variável de ambiente (não comando)
wo é comando e por isso leva ( )
TSW 57 TSW 58

Execução de comandos:
expressões
expansão aritmética usadas em expr e em $(( … ))
Expressão Descrição
4 $((...)) expr1 | expr2 expr1 se expr1 não é zero, senão expr2
expr1 & expr2 zero se qualquer expr for zero, senão expr1
– alternativa ao comando expr expr1 = expr2 igual
• expr é lento pois invoca nova shell para execução da expr1 > expr2 maior que
expr1 <= expr2 maior que ou igual
expressão expr1 < expr2 menor que
#!/bin/sh expr1 <= expr2 menor que ou igual
expr1 != expr2 diferente
x=0 expr1 + expr2 soma
while [ “$x” -ne 10 ]; do expr1 - expr2 subtração
echo $x expr1 * expr2 multiplicação aritméticas
x=$(($x+1))
expr1 / expr2 divisão inteira
done
expr1 % expr2 módulo
exit 0

TSW 59 TSW 60

10
 Fim de programação usando shell
– vimos uma breve introdução ao potencial de
programação usando shell
– domínio dos recursos vem com a prática
• muitos dos problemas de administração de um
sistema UNIX podem ser facilmente resolvidos com
programas shell aproveitando os recursos
disponíveis

TSW 61

11