Home Curso estruturas Mdulo Script Scripts shell Curso de Shell Script – Módulo #1: Scripts Shell e suas estruturas

Curso de Shell Script – Módulo #1: Scripts Shell e suas estruturas

Caso não tenha lido a primeira parte (módulo #0), veja-a em: http://www.profissionaisti.com.br/2011/05/curso-de-shell-script-modulo-0-comandos-basicos-do-linux/

Inicialmente, eu separaria este texto em vários módulos. Porém, optei por fazer algo mais sucinto e criar apenas este módulo – que complementa o Módulo #0, sobre os comandos básicos do Linux.

Neste módulo, serão abordados vários temas da programação em Shell (Bash), desde variáveis e funções, até expansões, expressões regulares etc.

Sem mais delongas, vamos ao que interessa!

0. Scripts Shell
1. Variáveis
1.1 Variáveis de Ambiente
1.2. Variáveis Especiais
2. Controle de Fluxo
2.1. Condicionais
2.1.1. if
2.1.2. case
2.1.3. select
2.2. Estruturas de Repetição (Loops)
2.2.1. for
2.2.2. while
2.2.3. until…do
2.2.4. break
2.2.5. continue
3. Padrão C/C++ em Expressões “(())”
4. Entrada/Saída
4.1. Redirecionamento
4.2. Usando Pipelines
5. Expansões
5.1. Expansão de Variáveis
6. Parâmetros de linha de comando
7. Definindo Funções
7.1. Retorno de Funções
8. Expressões Regulares em Bash
9. Expressões Matemáticas
10. O Arquivo .bashrc
11. Aliases (Apelidos)
12. Referências

Antes de mostrar os recursos do shell, vamos dar uma olhada na maneira como devemos criar scripts shell. Isso facilitará a compreensão do restante do artigo.

Todo arquivo com códigos shell deve ter, na primeira linha, o identificador do interpretador a ser utilizado. A “linha mágica” que chama o interpretado bash é:

O mesmo vale para outras linguagens interpretadas, como PHP, Python, Ruby, Perl etc.

Tendo essa linha no início do arquivo, o segundo passo é dar permissão de execução ao arquivo:

$ chmod +x script.sh Feito isso, basta executar o script:

Também é possível executar o script usando o comando bash:

Assim não é necessário haver a “linha mágica” no início do script. Também não é preciso dar permissão de execução ao arquivo.

O Bash, assim como muitas outras linguagens, possui o conceito de variável. Para definir uma variável:

nome_da_variavel="valor da variável"

É importante ressaltar que não deve haver espaços entre o símbolo de atribuição, o nome da variável e seu valor, para que o bash interprete o comando como atribuição, não chamada de comandos.

Para exibir o valor de uma variável, basta usar echo da seguinte forma:

As variáveis de ambiente são aquelas conhecidas pelos demais processos (programas em execução). Exemplos destas variáveis são: HOME, PATH, EDITOR, etc.

Para entender o seu uso, vejamos um exemplo: editores de texto, como Vi, possuem diferentes interfaces para os modos texto e gráfico e necessitam saber qual o tipo de terminal o usuário está usando. A variável de ambiente TERM é o modo pelo qual isto pode ser determinado. Outro exemplo são os programas de e-mail que permitem ao usuário editar mensagens com o editor de textos de sua preferência. Como estes programas sabem qual editor usar? É através da variável EDITOR ou VISUAL.

Qualquer variável pode se tornar uma variável de ambiente. Para isto, ela deve ser “exportada”, com o comando export:

Também podemos exportar e atribuir valores a uma variável numa única linha de comando:

Podemos verificar quais são as variáveis de ambiente já definidas e seus respectivos valores usando o comando abaixo:

Para visualizar todas as variáveis basta usar set ou env. Uma importante variável de ambiente é PATH que ajuda o shell a encontrar os comandos que o usuário executa. Todo comando executado é, na realidade, um arquivo. Estes arquivos são chamados executáveis e estão armazenados em vários diretórios como /bin ou /usr/bin. O valor da variável PATH é uma lista de diretórios em que o shell procura toda vez que executamos um comando cujo arquivo não é encontrado no diretório corrente. Assim, não precisamos alterar o diretório de trabalho todas vez que necessitamos executar um comando que se encontra em outro diretório. Basta acrescentar o diretório que contém tal comando à variável PATH. Os nomes dos diretórios na variável são separados pelo caractere dois-pontos (:).

Caso o usuário joao queira adicionar um outro diretório, digamos /home/joao/bin à variável PATH, deve proceder como mostrado a seguir:

$ export PATH=$PATH:/home/joao/bin # adiciona o diretório$ echo $PATH # verifica/bin:/usr/bin:/usr/local/bin:/home/joao/bin

O primeiro comando faz com que a variável receba o seu valor atual, concatenado com o nome do diretório a ser acrescentado. Observe que existe um “:” antes do nome do diretório. O segundo comando é utilizado apenas para visualizarmos o resultado do primeiro.

Existem algumas variáveis especiais, normalmente utilizadas em script shell, para verificação de parâmetros, valores de retorno de comandos e funções etc.

Parâmetro número 0 (nome do comando ou função)Parâmetro número 1 (da linha de comando ou função)Parâmetro número 9 (da linha de comando ou função)Parâmetro número 10 (da linha de comando ou função)Número total de parâmetros da linha de comando ou funçãoTodos os parâmetros, como uma string únicaTodos os parâmetros, como várias strings protegidasNúmero PID do processo atual (do próprio script)Número PID do último processo em segundo planoÚltimo argumento do último comando executadoValor de retorno do último comando executado

Controle de fluxo permite interromper, continuar e deslocar o fluxo de execução do script. Isso envolve controles de decisão (condicionais) e estruturas de repetição (loops).

Sintaxe:

ifthen comandoselif comandoselse comandosfi

O if, ao contrário do que ocorre em muitas outras linguagens, testa o retorno de um comando, não uma expressão.

Por exemplo:

if test 5 -lt 7then echo '5 é menor que 7'fi

Porém, é possível posicionar a expressão entre colchetes, de forma a tornar o if mais parecido com o que acontece em outras linguagens:

if [ 5 -lt 7 ]then echo '5 é menor que 7'fi

O “-lt” significa “less than“, ou seja, “menor que“, equivalendo ao operador “< “.

Outros possíveis operadores são:

Comparação Numérica
-lt: É menor que (LessThan)
-gt: É maior que (GreaterThan)
-le: É menor igual (LessEqual)
-ge: É maior igual (GreaterEqual)
-eq: É igual (EQual)
-ne: É diferente (NotEqual)

Comparação de Strings
=: É igual
!=: É diferente
-n: É não nula (não vazia)
-z: É nula (vazia)

Operadores Lógicos
!: NÃO lógico (NOT)
-a: E lógico (AND)
-o: OU lógico (OR)

Testes em arquivos
-b: É um dispositivo de bloco
-c: É um dispositivo de caractere
-d: É um diretório
-e: O arquivo existe
-f: É um arquivo normal
-g: O bit SGID está ativado
-G: O grupo do arquivo é o do usuário atual
-k: O sticky-bit está ativado
-L: O arquivo é um link simbólico
-O: O dono do arquivo é o usuário atual
-p: O arquivo é um named pipe
-r: O arquivo tem permissão de leitura
-s: O tamanho do arquivo é maior que zero
-S: O arquivo é um socket
-t: O descritor de arquivos N é um terminal
-u: O bit SUID está ativado
-w: O arquivo tem permissão de escrita
-x: O arquivo tem permissão de execução
-nt: O arquivo é mais recente (NewerThan)
-ot: O arquivo é mais antigo (OlderThan)
-ef: O arquivo é o mesmo (EqualFile)

Sintaxe:

case in opcao1) comandos ;; opcao2) comandos ;; *) operação padrãoesac

Exemplo:

echo "Digite um número"read x case "$x" in 1) echo "Você digitou o número 1" ;; 2) echo "Você digitou o número 2" ;; *) echo "Você digitou outro número"esac

Sintaxe:

select in ...do comandosdone

O comando select é pouco utilizado, mas pode ser muito útil para montar menus. Esse comando exibe um menu, associando cada opção a um número. Quando o usuário seleciona o número da opção, o seu valor é associado à.

Exemplo:

select i in lista_arquivos lista_arquivos_treedo case "$i" in lista_arquivos) ls ;; lista_arquivos_tree) ls -R ;; esacdone

Loops são estruturas que permitem fazer iterações sobre algum dado.

Sintaxe:

“var” é o nome da variável a ser usada no bloco de repetição. “lista” pode ser uma lista de dados, fixa ou retornada por outro comando (como o ls), uma sequência de números etc.

Exemplos:

Exibe uma sequência de números:

for i in 1 2 3 4 5do echo $idone

Lista os diretórios e arquivos da raiz do sistema de arquivos:

for i in $(ls /)do echo $idonefor i in $(seq 1 10)do echo $idonefor i in $(cat /etc/passwd)do echo $idone

Sintaxe:

Exemplos:

Exibe a sequência de 1 a 10:

i=0while [ $i -lt 10 ]do echo $i i=$((i+1))done

Loop infinito que exibe “bash” na tela:

while truedo echo 'bash'done

Lendo strings da entrada padrão:

while read ido echo 'Voce digitou a string: ' $idone

Exibe as linhas de um arquivo:

cat 'arquivo.txt' | while read ido echo $idone

Esse exemplo facilita o trabalho com arquivos de texto, cujas linhas possuem espaços. Se fosse usado um loop for nesse caso, seria necessário alterar a variável de ambiente IFS, definindo o separador para quebra de linha (\n).

Uma variação do exemplo anterior é esta:

while read ido echo $idone < arquivo.txt

A principal diferença entre estes dois últimos exemplos é que, no primeiro, o loop while é executado num subshell, devido ao uso do pipe (|). No segundo exemplo, o while é executado no shell corrente.

Para ilustrar o problema, crie um arquivo chamado “arq.txt” com algumas linhas de texto. Crie este script e execute-o:

#!/bin/bash FILE='arq.txt' total=0cat $FILE | while read idototal=$((total+1))doneecho 'Total de linhas: ' $total total=0while read idototal=$((total+1))done < $FILEecho 'Total de linhas: ' $total

O primeiro loop é executado num subshell, fazendo com que a variável “total”, usada no corpo do loop, existe apenas nesse subshell. No segundo caso, isso não ocorre. Isso pode gerar grandes dores de cabeça… (como já ocorreu comigo)

Sintaxe:

Nesse loop, a condição é oposta à usada no while. Por exemplo:

Com while:

i=0while [ $i -lt 10 ]do echo $i i=$((i+1))done

Com unitl:

i=0until [ $i -ge 10 ]do echo $i i=$((i+1))done

Para fazer a mesma coisa, tivemos que usar expressões diferentes na condição do loop.

O comando break encerra um loop imediatamente.

Exemplos:

i=0while truedo if [ $i -ge 10 ] then break fi i=$((i+1))donewhile read ido if [ $i -eq 0 ] then break fidone

O comando continue para a execução da iteração corrente e vai para a próxima iteração, mesmo que haja mais comandos no bloco de repetição.

É possível usar o padrão C em expressões do shell, como em condicionais de estruturas de controle. Para isso, basta colocar a expressão entre dois parênteses.

Exemplos;

i=0while (( i < 10 ))do echo $i ((i++))done

É possível, inclusive, usar o padrão do loop for do C:

for ((i = 0; i < 10; i++)do echo $idone

Existem três dispositivos principais, que sempre estão abertos, que merecem destaque:

stdin (standard input): entrada padrão. Corresponde, em geral, ao teclado;
stdout (standard output): saída padrão. Corresponde, em geral, à tela do terminal;
stderr (standard error): saída padrão de erros. Corresponde, em geral, à tela do terminal, também.

Esses três dispositivos estão em /dev e estão sempre disponíveis. Quem programa em C, sabe muito bem disso, pois já deve ter usado stdin, stdout e stderr junto com fprintf, fread, fwrite e semelhantes; esses três dispositivos comportam-se como arquivos comuns, sempre abertos e que não devem ser fechados.
É possível brincar com eles no próprio shell. Experimentem dar um cat em /dev/stdin para ver o que acontece.

A entrada de um programa consiste nos dados que lhe são passados inicialmente, os quais são necessários para a execução do programa. A entrada de um programa pode vir do teclado ou de um arquivo, por exemplo. Argumentos passados à comandos constituem a sua entrada.
A saída é constituída pelas informações geradas pelo programa, ou seja, o resultado de sua execução. A saída pode ser mostrada na tela ou gravada em um arquivo de registro.

Muitos comandos do Linux têm sua entrada configurada para a entrada padrão e sua saída para a saída padrão. A entrada padrão é o teclado e a saída padrão é o monitor. Vejamos um exemplo usando o comando cat, que lê dados de todos os arquivos passados como parâmetros e os envia diretamente para a saída padrão. Usando o comando abaixo, veremos o conteúdo do arquivo “arq1? seguido pelo conteúdo de “arq2?.

Entretanto, se nenhum nome de arquivo for dado como parâmetro, o comando cat lê dados da entrada padrão e os envia para a saída padrão. Para interromper, deve-se pressionar as teclas ctrl e d simultaneamente (ctrl+d).

$ catOla! Tem alguem ai? # usuárioOla! Tem alguem ai? # eco do sistemaAte mais! # usuárioAte mais! # eco do sistema # usuário pressiona ctrl+d

Como podemos ver, cada linha que o usuário digita é imediatamente ecoada pelo comando cat. Aqui um outro exemplo: o comando sort lê dados da entrada padrão – a menos que algum arquivo seja dado como parâmetro – e ordena os dados, enviando-os para a saída padrão:

$ sortbananas # usuárioperas # usuáriogoiabas # usuário # ctrl+dbananas # eco do sistemagoiabas # eco do sistemaperas # eco do sistema

Digamos que queremos enviar a saída do comando sort para um arquivo, gravando os dados digitados anteriormente. O shell nos permite redirecionar a saída para um arquivo usando o símbolo “>”.

$ sort > listabananas # usuárioperas # usuáriogoiabas # usuário # ctrl+d

Como se pode ver, o resultado do comando sort não é mostrado imediatamente após o se digitar ctrl+d. Ao invés disso, é salvo em um arquivo chamado “lista”. Vejamos o conteúdo desse arquivo:

$ cat listabananasgoiabasperas

Com o redirecionamento de saída, temos uma maneira simples de criar arquivos de texto. Para isso, utilizamos o comando cat para ler a entrada padrão (teclado) e redirecionamos sua saída para um arquivo.

Ao usar “>” para redirecionar a saída para um arquivo, estamos realizando um redirecionamento destrutivo, ou seja, o comando “ls > lista” sobrescreve o conteúdo do arquivo “lista”. Isto é equivalente a dizer que todo o conteúdo anterior de “lista” é apagado.
Se, ao invés disso, redirecionarmos usando “>>”, a saída será concatenada ao final do arquivo e o conteúdo (se houver) de “lista” será preservado. Para melhor entender isso, experimente executar a seguinte seqüência de comandos:

ls >> listagemls >> listagemless listagem

O redirecionamento neste exemplo, diferentemente do exemplo anterior, é denominado redirecionamento não-destrutivo.

Nos exemplos para o filtro sort, os dados de entrada eram digitados pelo usuário ou estavam gravados em um arquivo. O que aconteceria se quiséssemos ordenar dados vindos do saída de outro comando ? Para listar os arquivos do diretório corrente em ordem alfabética invertida devemos fazer com que a saída do comando ls seja ordenada pelo comando sort. Usando a opção “-r”, este comando ordena os dados na ordem inversa.

$ lshistoria notas tese testes$ ls > lista$ sort -r listatestestesenotaslista # observe esse nome de arquivohistoria

Aqui, salvamos a saída do comando ls em um arquivo (lista) e usamos sort com a opção “-r”. Porém, isso faz com que tenhamos um arquivo temporário para armazenar os dados. Assim, toda vez que fizermos isso, teremos que, em seguida, remover o arquivo lista. A solução é usar o que chamamos de pipeline, outro recurso do shell que nos permite conectar vários comandos usando um pipe, onde a saída do primeiro comando é enviada diretamente à entrada do segundo e assim por diante no caso de haver mais de dois comandos conectados por pipes.

No nosso caso, queremos enviar a saída do comando ls para a entrada do comando sort. O símbolo “|” (barra vertical) é usado para criar um pipe:

$ ls | sort -rtestestesenotashistoria

Note que neste exemplo, nenhum nome de arquivo é usado na linha de comando, diferentemente do exemplo anterior que fazia o uso do arquivo intermediário lista. Outra diferença é que o nome desse arquivo intermediário aparece no resultado do penúltimo exemplo, mas não neste último. O comando é mais curto, mais fácil de digitar e o resultado é mais adequado pois não inclui nomes de arquivos intermediários.

É importante observar que o redirecionamento e o uso de pipes são características do shell e não dos comandos em si. É o shell quem provê a sintaxe dos símbolos “>”, “< ” e “|”. Logo, se você criar um programa que utilize entrada de dados via stdin, poderá usar redirecionamento para especificar uma entrada para o seu programa.

Expansões são caracteres, ou uma sequência deles, que expressa outro significado. O intuito disso é facilitar e padronizar comandos.

~: path à home do usuário corrente
~user: path à home do usuário “user”
{a,b,c}: presença do caractere “a”, “b” ou “c”. Podem ser usadas strings em vez de simplesmente caracteres.

Exemplos:

Se var não está definida, retorna ‘texto’Se var não está definida, defina-a com ‘texto’Se var não está definida, retorna o erro ‘texto’Se var está definida, retorna ‘texto’, senão retorna o vazioÉ o mesmo que $var, porém não ambíguoExecuta o conteúdo de $var (igual ‘eval \$$var’)Retorna os nomes de variáveis começadas por ‘texto’Retorna o texto a partir da posição ‘N’Retorna ‘tam’ caracteres a partir da posição ‘N’Corta ‘texto’ do início da stringCorta ‘texto’ do início da string (* guloso)Corta ‘texto’ do final da stringCorta ‘texto’ do final da string (* guloso)Substitui ‘texto’ por ‘novo’, uma vezSubstitui ‘texto’ por ‘novo’, sempreSe a string começar com ‘texto’, substitui ‘texto’ por ‘novo’Se a string terminar com ‘texto’, substitui ‘texto’ por ‘novo’

Assim como em outras linguagens, é possível passar parâmetros para scripts shell. Para isso, usam-se as variáveis $1, $2, … A variável $0 contém o comando chamado via linha de comando.

Exemplo:

Crie um arquivo “test.sh” com este conteúdo:

#!/bin/bash echo '$0 = '$0echo '$1 = '$1echo '$2 = '$2

Veja as saídas das execuções abaixo:

$ ./test.sh$0 = ./test.sh$1 =$2 =$ ./test.sh um$0 = ./test.sh$1 = um$2 =$ ./test.sh um dois$0 = ./test.sh$1 = um$2 = dois

Sintaxe:

function nome_da_funcao(){ }

Para chamar a função:

nome_da_funcao # caso haja parâmetrosnome_da_funcao param1 param2 ...

Exemplo:

#!/bin/bash function imprime(){echo "Sou a função '${0}'"echo "Param 1: ${1}"echo "Param 2: ${2}"echo "Lista de parâmetros: ${*}"} imprime um dois tres quatro

Da mesma forma como foram usados $0, $1 etc anteriormente, aqui essas variáveis são usadas para retornar os parâmetros da função. Logo, percebe-se que, dentro de funções, não é possível acessar parâmetros de script, a menos que eles sejam passados por parâmetro para a função.

Antes de tudo, é preciso diferenciar retorno de função e saída de função. Por exemplo, ao se executar o comando “cat /etc/passwd”, a saída é o conteúdo do arquivo; o retorno é 0 (ou outro valor, caso ocorra erro). O retorno de uma função shell é um valor inteiro, normalmente utilizado para definir o status da função, ou seja, se ocorreu algum erro ou e ela foi executada corretamente.

Para obter o valor de retorno de uma função, usa-se a variável “$?”. Ela exibe o retorno do último comando executado. Por exemplo:

Para retornar valor (status) numa função, usa-se o comando return.

Exemplo:

#!/bin/bash function retorna(){ echo "sou um valor" return 42} valor=$(retorna)echo $?echo $valor

Ao se executar a função, sua saída será “sou um valor”; seu retorno será 42.

Em shell, considera-se o valor 0 como execução bem sucedida. Qualquer outro valor representa erro. É por isso que recomenda-se que toda função main de um programa em C retorne o valor 0, desde que não ocorra algum erro.

Expressões regulares em shell podem ser usadas em comparações (if’s), por exemplo. Em if’s, usa-se o operador “=~” para realizar comparações usando ER’s:

s="bash"if [[ "$s" =~ ^b ]]then echo 'começa com b'fi

O bash não trabalha com expressões matemáticas tão facilmente. Existe o comando “let”, que permite realizar expressões matemáticas, mas é mais comum se usar a sintaxe semelhante ao C, utilizando dois parênteses:

$ a=$((1 + 1))$ ((i++))$ x=$((x*2))...

Na home dos usuários (~), é comum haver o arquivo .bashrc (o ponto no início indica que o arquivo é oculto). Esse arquivo é sempre executado quando se abre um shell. Nele, constam diversas configurações, como definição de variáveis de ambientes, definição de aliases etc. Você pode editar esse arquivo (ou criá-lo, caso não exista):

É possível usar outros editores, não apenas o vim.

Algumas vezes usamos comandos que necessitam de várias opções e argumentos. Para amenizar o trabalho de digitarmos repetidamente estes comandos o bash oferece um recurso chamado alias com o qual podemos definir sinônimos ou “apelidos” para um comando. Um alias pode ser definido na linha de comando da seguinte forma:

Observe que não pode haver espaços em branco antes ou depois do “=”.

Esta sintaxe indica que nome é um “alias” (apelido) para comando. Toda vez que digitarmos o comando “nome”, o bash o substituirá por “comando”.

Exemplo:

Isso fará o shell executar “ls -F” toda vez que usarmos “lf” na linha de comando. Ou seja, o que o alias faz na verdade é substituir a palavra “lf” por “ls -F”. Observe neste exemplo, existe um espaço em branco entre ls e -F. Sempre que houver espaços em branco na definição de um campo, todo o campo deve ser digitado entre aspas simples (‘) ou duplas (“).

É possível definir aliases em seu .bashrc, para que eles estejam sempre disponíveis na sua sessão.

Linux Básico:
http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxBasico/ ou http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxBasico.pdf

Linux Avançado
http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxAvancado.pdf

Canivete Suiço do Shell (Bash)
http://aurelio.net/shell/canivete/

Livro Shell Script Profissional (Livro físico):
http://www.shellscript.com.br/

—————————

Originalmente postado no meu blog, em: http://www.rberaldo.com.br/blog/curso-de-shell-script-modulo-1-scripts-shell-estruturas

Siga-me no Twitter: @rberaldo
Facebook: http://www.facebook.com/rberaldo42