torradeira.net

Nesta aula vamos aprender sobre comandos de laço como o while, for, case e select. Eles nos permitem executar alguns comandos diversas vezes, sob determinadas condições e até montar menuzinhos para interagir com o usuário.

While

Nesta terceira parte do nosso curso de shell script, vamos tratar de “condicionais”.Condicionais são comandos que avaliam uma expressão. Se ela for verdadeira, uma determinada rotina é executada. Caso contrário, outra rotina pode ser executada.

O famoso “if”

O bash nos oferece, entre outros, o comando IF (ele é um comando embutido no bash e não um programa como o “ls”, o “cp” etc.). A forma mais simples de representar uma condicional utilizando o IF, é da seguinte forma básica:

if [condição];
then comandos1;
else comandos2;
fi;

Se [condição] for verdadeira, os comandos1 são executados. Se for falsa, os comandos2 são executados.Mas para o IF, o que é uma condição verdadeira ou uma falsa?

Como foi explicado na aula anterior, TODO comando em Unix tem um código de retorno. Geralmente o código “0″ (zero) significa que o comando foi executado perfeitamente e terminou bem. Códigos maiores que zero significam que alguma coisa de errado ocorreu.

É assim que o IF verifica uma condição. Se o seu código de retorno for zero, então ela é considerada verdadeira. Caso contrario, ela é falsa.Mas então a [condição] tem que ser um comando, certo? Exatamente. Vamos exemplificar:

neo@matrix:~$ if ls /boot; then echo “O diretório existe.”; else echo “Diretório inválido.”; fi;
System.map boot.0300 boot.b boot_message.txt chain.b config map os2_d.b
O diretório existe.

O que fizemos?

Logo após o if, nós colocamos um comando: “ls /boot”. O que o IF faz? Ele executa esse comando (por isso que temos a segunda linha começada por “System.map”, que é o conteúdo do meu diretório /boot) e avalia o seu código de saída. Como o “ls” foi executado corretamente, ele retorna zero, significando verdadeiro para o IF, que executa o comando logo após o “then”, ou seja, o echo “O diretório existe.”, mostrando essa mensagem no console.

Agora vamos colocar um diretório que não existe:

neo@matrix:~$ if ls /dir_invalido; then echo “O diretório existe.”; else echo “Diretório inválido.”; fi;
/bin/ls: /dir_invalido: Arquivo ou diretório não encontrado
Diretório inválido.

A lógica é a mesma. Executa o “ls /dir_invalido”, que retorna um código maior que zero. O IF avalia como falso e executa o comando após o else: echo “Diretório inválido”.

Nós poderíamos omitir a segunda linha dos dois exemplo (a que mostra o conteúdo de /boot no primeiro exemplo e a mensagem de erro emitida pelo ls dizendo que /dir_invalido não existe no segundo), apenas redirecionando as saídas para /dev/null, ou seja:

neo@matrix:~$ ls /boot 1> /dev/null 2> /dev/null

Nota: Tem um macete que possui o mesmo efeito. Em vez de colocar: “1> /dev/null 2> /dev/null” podemos colocar “2&>1″, que é menor e mais simples.

O comando “test”

Bom, aprendemos que o IF avalia a código de retorno de um comando. Mas muitas vezes, para não dizer a maioria, nós queremos avaliar “expressões”, ou seja, verificar se uma variável é igual a outra, se ela esta vazia etc.

Para isso, nós temos outro comando chamado “test” (intuitivo o nome, não?). Ele funciona da seguinte maneira: test [expressão].

O test pode testar operações de três tipos: strings, arquivos e aritméticas.

Expressões usando strings:

O test pode apenas comparar strings, ou seja, verificar se uma é igual a outra, e verificar se uma string é vazia ou não. Vamos aos exemplos para facilitar o entendimento:

neo@matrix:~$ test “a” = “a”
neo@matrix:~$ echo $?
0
neo@matrix:~$ test “a” = “b”
neo@matrix:~$ echo $?
1
neo@matrix:~$ test “a” != “b”
neo@matrix:~$ echo $?
0

Aqui comparamos a string “a” com “b”. Como era de se esperar, o primeiro retornou verdadeiro (zero), pois a = a e o segundo retornou falso. No terceiro, o símbolo “!=” significa “diferente”.

neo@matrix:~$ test -z “neo”
neo@matrix:~$ echo $?
1
neo@matrix:~$ test -z “”
neo@matrix:~$ echo $?
0
neo@matrix:~$ test -n “neo”
neo@matrix:~$ echo $?
0
neo@matrix:~$ test -n “”
neo@matrix:~$ echo $?
1

Acima temos os testes de vazio. A opção “-z” verifica se é vazio, e “-n” se não é vazio. No primeiro caso, ele testa se “neo” é uma string vazia, retornando falso. Já no segundo caso, como “” é vazia, retorna verdadeiro. O terceiro e quarto são semelhantes aos primeiros, mas com “-n”.

Expressões com arquivos:

Os testes que podem ser feitos com arquivos são para verificar determinadas caracteristicas, como se ele existe, se é executavel, se é um link simbólico, se é um diretório etc.

Alguns exemplos:

A opção “-e” verifica apenas se um arquivo existe e a opção “-d” verifica se o arquivo é um diretório.

A opção “-nt” verifica se o primeiro arquivo é mais novo que o segundo (nt = newer than) e “-ot” verifica se o primeiro é mais velho que o segundo (od = older than):

neo@matrix:~$ test -e /vmlinuz
neo@matrix:~$ echo $?
0
neo@matrix:~$ test -d /vmlinuz
neo@matrix:~$ echo $?
1
neo@matrix:~$ test -e /usr
neo@matrix:~$ echo $?
0
neo@matrix:~$ test -d /usr
neo@matrix:~$ echo $?
0
neo@matrix:~$ test /usr -nt /vmlinuz
neo@matrix:~$ echo $?
0
neo@matrix:~$ test /usr -ot /vmlinuz
neo@matrix:~$ echo $?
1

O comando “test” (continuação)

A seguir, temos uma lista de várias opções disponíveis:

* -b arquivo – Verdadeiro se arquivo é um arquivo de bloco, como /dev/hda.
* -c arquivo – Verdadeiro se arquivo é um arquivo de caracter, como /dev/tty1.
* -d arquivo – Verdadeiro se arquivo é um diretório.
* -e arquivo – Verdadeiro se arquivo existe.
* -f arquivo – Verdadeiro se arquivo existe e é um arquivo comum.
* -s arquivo – Verdadeiro se arquivo existe e não é vazio.
* -h arquivo – Verdadeiro se arquivo é um link simbólico.
* -p arquivo – Verdadeiro se arquivo é um “named pipe” (fifo, lifo, etc).
* -S arquivo – Verdadeiro se arquivo é um “socket”.
* -k arquivo – Verdadeiro se arquivo tem seu “sticky bit” ligado.
* -r arquivo – Verdadeiro se arquivo pode ser lido pelo usuário atual.
* -w arquivo – Verdadeiro se arquivo pode ser escrito pelo usuário atual.
* -x arquivo – Verdadeiro se arquivo pode ser executado pelo usuário atual.
* -O arquivo – Verdadeiro se arquivo pertence ao usuário atual.
* -G arquivo – Verdadeiro se arquivo pertence ao grupo do usuário atual.
* -N arquivo – Verdadeiro se arquivo foi modificado desde a ultima vez que foi lido.

Expressões Aritméticas

Expressões aritméticas consistem com comparar dois números, verificando se são iguais, ou se o primeiro é maior que o segundo etc.

Infelizmente não podemos apenas utilizar os símbolos conhecidos para igual (=), maior que (>), menor que (<) etc. Temos que usar operadores reconhecidos pelo "test". Assim, não podemos fazer: "test 1 = 1", devemos utilizar o operador "-eq" (equal): "test 1 -eq 1". A seguir, temos uma lista dos operadores:

* -eq (equal): Igual;
* -ne (not-equal): Não Igual (diferente);
* -lt (less than): Menor que (<);
* -le (less than or equal): Menor ou igual ( <= );
* -gt (greater than): Maior que (>);
* -ge (greater than or equal): Maior ou igual (>=);

Alguns exemplos:

neo@matrix:~$ test 1 -lt 2
neo@matrix:~$ echo $?
0
neo@matrix:~$ test 1 -gt 2
neo@matrix:~$ echo $?
1
neo@matrix:~$ test 2 -gt 1
neo@matrix:~$ echo $?
0
neo@matrix:~$ test 2 -ge 2
neo@matrix:~$ echo $?
0

Para finalizar, vamos fazer duas considerações. A primeira é de que o comando “test” pode ser substituido por um par de colchetes [ ]. Assim, o comando test “a” = “b” pode ser escrito como [ "a" = "b" ] .

Essa segunda nomenclatura fica mais fácil e simples, principalmente quando estamos utilizando IF:

if [ -e /vmlinuz ]; é mais intuitivo e simples que if test -e /vmlinuz; .

A segunda consideração é que, obviamente, podemos utilizar variáveis no lugar dos argumentos (caso contrário, ficaria difícil utilizar comandos de condicionais em shell script). Assim, se tivermos duas variaveis, valor1=5 e valor2=8:

[ "$valor1" = "$valor2" ] , [ "$valor1" -lt "$valor2" ] etc.

É importante colocarmos os valores entre aspas duplas (“), pois assim o bash pode substituir o que se encontra dentro dessas aspas. Se colocarmos entre aspas simples (‘), impedimos o bash de alterar o que se encontra dentro delas. Se não utilizarmos as aspas duplas, vamos ter problemas, principalmente ao trabalharmos com string.

Por exemplo, queremos comparar dois nomes, que se encontram em duas variaveis:nome1=”fulano de tal” e nome2=”ciclano”.Montando nossa expressão condicional: [ "$nome1" = "$nome2" ].O bash irá expandir isso para: [ "fulano de tal" = "ciclano" ], ficando claramente definidos o primeiro e o segundo argumento.

Agora, se não usarmos aspas: [ $nome1 = $nome2 ]. O bash irá expandir isso para: [ fulano de tal = ciclano ]. Perceba que os argumentos se misturam e o bash não vai saber o que comparar.Por isso é importante colocarmos os argumentos entre aspas duplas.

Conclusão

Na aula de hoje vamos falar sobre execução de programas em primeiro plano (fg – foreground) e em segundo plano (bg – background), redirecionamento de saídas e também sobre os códigos de escape dos programas.

Execução em foreground e background

Quando executamos um programa, o shell fica esperando o mesmo terminar para depois nos devolver a linha de comando. Por exemplo, quando executamos o comando cp arquivo1 arquivo2,o shell executa esse comando, fica esperando ele terminar, para depois nos retornar a linha de comando. Isso chama-se execução em primeiro plano, ou foreground, em inglês.Agora digamos que o arquivo a ser copiado seja muito grande, digamos, 50Mb. Enquanto o comando cp é executado, vamos ficar com o shell preso a ele todo esse tempo, ou seja, cerca de 1 ou 2 minutos. Somente após isso vamos ter a linha de comando de volta para podermos continuar trabalhando.

E se pudéssemos dizer ao shell para executar um programa e nos retornar a linha de comando sem ficar esperando o tal programa terminar? Seria muito melhor, não? Em alguns casos seria. E podemos fazer isso.

Uma maneira fácil é colocar o sinal de & depois de um comando. No exemplo acima ficaria:

neo@matrix:~$ cp arquivo1 arquivo2 &
[1] 206
neo@matrix:~$

Pronto, assim que teclarmos [enter], teremos a nossa linha de comando de volta e mais duas informações: “[1] 206″.

A primeira informação ([1]) chama-se job. Ela identifica os programas que estão sendo executados em bg (background). Por exemplo, se executarmos mais um programa em bg enquanto este “cp” está sendo executado, o novo programa recebe o job de número 2 ([2]) e assim por diante.

A segunda informação (206) é o pid do programa, ou seja, o número de processo que o kernel dá a esse programa.

Mas aí temos um pequeno problema. Digamos que você queira trazer o programa para fg, por exemplo, se o programa executado em bg for um tocador de mp3 e você quiser mudar a música. Como fazemos? Usamos o comando fg [job] (intuitivo, não ?) do bash. No exemplo acima, digamos que eu execute o “cp” em bg, mas depois queira trazê-lo para fg para cancelá-lo. Seria simples:

neo@matrix:~$ cp arquivo1 arquivo2 &
[1] 206
neo@matrix:~$ fg 1
cp arquivo1 arquivo2

Assim trazemos o “cp” para primeiro plano e a linha de comando só retorna quando ele terminar.

Opcional

Uma outra maneira de colocar um programa para rodar em bg é utilizando um truque do bash (não sei se esta opção está disponível em outros shells).Digamos que você execute o comando “cp” e esqueça de colocar o sinal “&”. E aí? Tem que ficar esperando acabar ou cancelar o comando? Não, podemos teclar: Ctrl + Z.

Ao fazer isso, paramos a execução do programa. Então é só dar o comando bg [job] (intuitivo também, né?):

neo@matrix:~$ cp arquivo1 arquivo2

* aqui teclamos Ctrl + Z *
[1]+ Stopped cp -i arquivo1 arquivo2
neo@matrix:~$ bg 1
[1]+ cp -i arquivo1 arquivo2 &
neo@matrix:~$

Quando teclamos o Ctrl + Z, o bash nos diz que o job 1 foi parado ([1]+ Stopped) e quando executamos “bg 1″ ele nos diz que o comando voltou a ser executado, mas em bg (repare o sinal de “&” no final da linha): [1]+ cp -i arquivo1 arquivo2 &.

Redirecionamento de saídas

Muitos programas que executamos geram saídas no console, ou sejam, emitem mensagens para os usuários. Por exemplo, queremos achar quantos arquivos no nosso sistema tem “netscape” no nome:

neo@matrix:~$ find / -name netscape
/usr/lib/netscape
/usr/lib/netscape/netscape
/usr/lib/netscape/nethelp/netscape
/usr/local/bin/netscape

Agora se quisermos procurar quantos arquivos compactados com o gzip (extensão .gz) tem no nosso sistema para depois analisá-los e possivelmente apagar os repetidos ou inúteis, teremos uma lista muito grande. Aqui no meu sistema deu mais de 1000 arquivos. Então, seria útil podermos enviar as mensagens que vão para o console, para um arquivo. Assim, poderíamos analisá-lo depois de executar o comando. Isso é extremamente útil ao trabalharmos com shell script – enviar as saídas dos comandos para arquivos para depois analisá-las. Exemplificando:

neo@matrix:~$ find / -name “*.gz” > lista.txt
find: /home/vera: Permissão negada
find: /home/pri: Permissão negada
find: /root: Permissão negada
neo@matrix:~$

Notamos que nem tudo foi para o arquivo lista.txt. As mensagens de erro foram para o console.

Isso porque existem dois tipos de saída: a saída padrão e a saída de erro.A saída padrão é a saída normal dos programas, que no caso acima, seria os arquivos encontrados. E a saída de erro, como o próprio nome diz, são os erro encontrados pelo programa durante sua execução, que devem ser informados ao usuário, como os erros de “permissão negada”.

E aí, como selecionar uma ou outra? É simples, apenas devemos indicar o “file descriptor” (fd) delas. Não vamos entrar em detalhes sobre o que é “descritor de arquivos” por fugir do nosso escopo e ser um pouco complicado, apenas temos que saber que o fd 1 corresponde a saída padrão e o fd 2 a saída de erro. Assim, no exemplo acima, para enviar os erro para o arquivo erros.txt e a saída padrão para o arquivo lista.txt, usaríamos:

neo@matrix:~$ find / -name “*.gz” 1> lista.txt 2> erros.txt

Ou seja, é só por o número da saída desejada antes do sinal de “>”.

Agora digamos que queremos ver o conteúdo do arquivo lista.txt. Podemos abrí-lo com um editor de textos ou usar o “cat”. Optando pela última opção:

neo@matrix:~$ cat lista.txt
/home/neo/gkrellm-0.10.5.tar.gz
/home/neo/linuxcall-interface-beta.tar.gz
…
<<< mais de 1000 linhas
neo@matrix:~$

Temos um problema. O arquivo tem mais de 1000 linhas e não conseguimos vê-lo inteiro. Podemos redirecionar a saída do comando "cat" para o comando "more", que dá pausa entre as telas:

neo@matrix:~$ cat lista.txt | more
.........

Veja que utilizamos o caractere "|", chamado "pipe". Não poderíamos ter utilizado o sinal de ">“? Não, o sinal de “>” é somente para enviar a saída para um ARQUIVO. Para enviar a saída de um comando para a entrada de outro, usamos o pipe.

As vezes queremos que além da saída ir para um arquivo, ela também vá para a tela. Temos um programinha que faz isso. Ele chama-se “tee”. Veja o exemplo a seguir:

neo@matrix:~$ find / -name “*.gz” 2> erros.txt | tee lista.txt

O que fizemos???Primeiro pegamos a saída de erro e enviamos para o arquivo erros.txt. O restante, ou seja, a saída padrão, estamos enviando para a entrada do comando tee (usando o pipe). O tee simplesmente pega o que ele recebe (através do pipe) e joga no arquivo lista.txt e na tela. Assim, além de gravarmos a saída num arquivo, podemos mostrar ao usuário o que está acontecendo. Isso é muito útil quando escrevemos alguns scripts.

Resumindo: aprendemos que podemos redirecionar a saída padrão ou de erro de programa para um arquivo usando respectivamente “1>” ou “2>” ou também enviar a saída para a entrada de outro programa usando o pipe “|”.

Códigos de Escape

Toda vez que executamos um programa em Unix, ele retorna um código de escape ao finalizar. Esse código reflete a condição em que o programa finalizou. Se ocorreu tudo certo e o programa terminou normalmente, ele retorna 0. Se ocorreu algum problema, o programa retorna um código diferente de 0, geralmente variando com o problema ocorrido.

Esse código de retorno é extremamente importante em shell script, pois é assim que testamos se uma certa ação ocorreu bem ou teve problemas.Esse código é armazenado pelo bash numa variável chamada “?” (isso mesmo, somente o sinal de interrogação ).

Por exemplo, vamos executar um “ls” em um diretório que existe e ver o código de retorno:

neo@matrix:~$ ls /boot
System.map boot.0300 boot.b boot_message.txt chain.b config map os2_d.b
neo@matrix:~$ echo $? 0
neo@matrix:~$

Ou seja, o “ls” foi executado normalmente, retornando 0. Agora vamos executá-lo num diretório que não existe:

neo@matrix:~$ ls /diretorio_invalido
/bin/ls: /diretorio_invalido: Arquivo ou diretório não encontrado
neo@matrix:~$ echo $?
1
neo@matrix:~$

Como esperado, obtemos o retorno de erro 1.

Alguns programas tem muitos códigos de retorno. Por exemplo, os códigos de retorno do “pppd” vão até o 19. Assim é possível saber porque ele foi finalizado. Se você colocar uma senha errada no pppd e tentar conectar, ele vai terminar com o código 19.

man pppd
…
17 The PPP negotiation failed because serial loopback was detected.
18 The init script failed (returned a non-zero exit status).
19 We failed to authenticate ourselves to the peer.
…

Um detalhe importante: quando executamos um programa em background, ele sempre retorna um código 0 para o shell, mesmo que durante sua execução ocorra algum problema. Assim, quando executamos um programa em bg, perdemos essa facilidade de testar como foi seu término.

neo@matrix:~$ ls /diretorio_invalido &
[1] 230
neo@matrix:~$ /bin/ls: /diretorio_invalido: Arquivo ou diretório não encontrado

[1]+ Exit 1 /bin/ls $LS_OPTIONS /diretorio_invalido
neo@matrix:~$ echo $?
0

Como vemos, ao terminar, ele emite uma mensagem dizendo que finalizou com código 1 ([1]+ Exit 1) mas quando testamos a variável “?”, o bash nos diz “0″.

Conclusão

Como todos os programas tem que terminar com um código de retorno que tenha algum significado, nossos shell scripts também terão que finalizar indicando o que aconteceu, se ocorreu tudo bem ou se ouve erro. Mas isso discutiremos melhor mais pra frente.

O que são os shell scripts? Shell scripts são conjuntos de comandos armazenados em um arquivo texto que são executados seqüencialmente. Nesta primeira parte, faremos uma introdução sobre o shell, o formato desses arquivos e variáveis de ambiente.

O que é Shell

Shell, ou interpretador de comandos, é o programa disparado logo após o login responsável por “pegar” os comandos do usuário, interpretá-los e executar uma determinada ação.

Por exemplo, quando você escreve no console “ls” e pressiona , o shell lê essa string e verifica se existe algum comando interno (embutido no próprio shell) com esse nome. Se houver, ele executa esse comando interno. Caso contrário, ele vai procurar no PATH por algum programa que tenha esse nome. Se encontrar, ele executa esse programa, caso contrário, ele retorna uma mensagem de erro. Para cada terminal ou console aberto, existe um shell sendo executado. Quando você entra no seu Linux, ele apresenta o login, para digitar o usuário e a senha. Ao digitar um par usuário/senha correto, o Linux abre automaticamente um shell, que vai ficar esperando seus comandos. Veja o exemplo abaixo:

Welcome to Linux Slackware 10.1 kernel 2.4.16.

matrix login: neo
Password:

Linux 2.2.16.
Last login: Mon Sep 25 10:41:12 -0300 2000 on tty1.
No mail.

neo@matrix:~$

Essa ultima linha é o shell. Se você der o comando “ps”, vai ver que um dos programas rodando é o seu shell:

neo@matrix:~$ ps
PID TTY TIME CMD
164 tty2 00:00:00 bash
213 tty2 00:00:00 ps
neo@matrix:~$

Ou seja, o shell utilizado nesse console é o bash, que está rodando com PID 164.

Existem diversos tipos de shell: bash, csh, ksh, ash, etc. O mais utilizado atualmente é o bash (GNU Bourne-Again SHell). Por isso, tomaremos ele como referência.

Resumindo essa seção, é importante saber que para cada terminal ou console aberto, tem-se um shell rodando. Assim, se você tem 3 xterms abertos na interface gráfica, vai ter um shell para cada xterm.

Ao executar o shell script, o shell atual (no qual você deu o comando) abre um novo shell para executar o script. Assim, os scripts são executados em um shell próprio (a menos que se especifique, ao chamar o script, para executá-lo no shell atual). Isso será importante quando formos tratar de variáveis de ambiente.

Variáveis do ambiente

Uma variável é onde o shell armazena determinados valores para utilização posterior.

Toda variável possui um nome e um valor associado a ela, podendo ser este último vazio. Para listar as variáveis atualmente definidas no shell digite o comando set .

Para se definir uma variável, basta utilizar a síntaxe: nome_da_variável=valor . Por exemplo, queremos definir uma variável chamada “cor” com o valor de “azul”:

neo@matrix:~$ cor=azul

Para utilizar o valor de uma variável, é só colocar um sinal de “$” seguido do nome da variável – o shell automaticamente substitui pelo valor da variável:

neo@matrix:~$ echo cor
cor
neo@matrix:~$ echo $cor
azul

Em alguns casos, é aconselhável colocar o nome da variável entre chaves ({}). Por exemplo, se eu quero imprimir “azul-escuro”, como faria? Simplesmente echo $cor-escuro ?? Não funcionaria, pois o bash vai procurar uma variável de nome “cor-escuro”. Portanto, temos que colocar o nome “cor” entre chaves para delimitar o nome da variável:

neo@matrix:~$ echo ${cor}-escuro
azul-escuro

Algumas variáveis já são predefinidas no shell, como o PATH, que, como foi dito antes, armazena o caminho dos programas. Por exemplo, a minha variável PATH contém:

neo@matrix:~$ echo $PATH
/usr/local/bin:/usr/bin: /bin: /usr/X11R6/bin: /usr/openwin/bin: /usr/games: /opt/kde/bin: /usr/share/texmf/bin: /etc/script

Ou seja, quando digito um comando, como “ls”, o shell vai começar a procurá-lo em /usr/local/bin, se não encontrá-lo, vai procurar em /usr/bin e assim por diante. Repare que os diretórios são separados por um sinal de dois pontos (:).

É importante destacar que o shell possui várias variáveis pré-definidas, ou seja, que possuem um significado especial para ele, entre elas: PATH, PWD, PS1, PS2, USER e UID.

Assim, quando iniciamos um novo shell (ao executar o nosso script), essas variáveis especiais são “herdadas” do shell pai (o que executou o shell filho). Outras variáveis definidas pelo usuário, como a variável “cor” não são passadas do shell pai para o filho.

Quando o script terminar, o seu shell (shell filho) simplesmente desaparece e com ele também as suas variáveis, liberando o espaço ocupado na memória.

Formato dos arquivos de Shell Script

A primeira linha de todo shell script deve começar com algo do tipo: #!/bin/bash , a qual indica com qual shell deverá ser executado o script.Nesse exemplo, estamos falando para o shell atual executar o script com o shell /bin/bash.Se quisermos que o nosso script seja executado com o shell csh, devemos colocar nessa primeira linha: #!/bin/csh .

Como usaremos o bash como nosso shell de referência, todas as linhas dos nossos scripts começarão com #!/bin/bash

Digamos que você executa freqüentemente o comando: find / -name file -print , que procura na raiz (/) por um arquivo de nome “file”. Só que é chato ficar digitando esse comando toda vez que se quer procurar um arquivo.

Então vamos criar um shell script que contenha esse comando. Vamos chamar esse shell script de “procura”. Seu conteúdo fica assim:

#!/bin/bash
find / -name file -print

Pronto. Tornemos agora o arquivo executável: chmod 755 ./procura . Porém, ao tentar executar o nosso script, teremos um problema.

./procura

Este script irá procurar por um arquivo chamado “file”.Como especificar qual arquivo queremos procurar? Seria ideal executarmos o nosso script seguido do nome do arquivo que queremos procurar.

Por exemplo, queremos saber onde está o arquivo “netscape”: ./procura netscape . É ai que entram as “variáveis de parâmetro”. Vamos substituir no nosso script a linha find / -name file -print por find / -name $1 -print .

Quando o bash lê a variável “$1″, ele a substitui pelo primeiro parâmetro passado na linha de comando para o nosso script. Então, se executamos ./procura netscape , a variável “$1″ será substituída por “netscape”, como a gente queria. Repare que a variável “$2″ conteria o segundo parâmetro passado para o script e assim por diante.

Sendo assim, qualquer comando colocado abaixo de find seria executado após ele. Esse é o essencial do shell script: poder automatizar a execução de programas e comandos como se estivessem sendo digitados diretamente no console ou terminal.

Conclusão

Na próxima aula do nosso curso de shell script iremos aprender alguns comandos especiais para tornar nossos script mais poderosos, fazendo coisas mais elaboradas do que apenas executar programas seqüencialmente. Entre eles, podemos destacar os comandos de laço, como “if”, “for”, “while”, “case” etc.

echo 1 > /proc/sys/net/ipv4/ip_forward // Habilitando o recurso de IP forwarding