Inicialmente, eu separaria este texto em vários módulos. Porém, optei por faer 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! :)

Sumário

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

0. Scripts Shell

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 é:

#!/bin/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
<pre>
 
Feito isso, basta executar o script:
 
<pre lang="bash">
$ ./script.sh

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

$ bash script.sh

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.

1. Variáveis

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:

echo $nome_da_variavel

1.1 Variáveis de Ambiente

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:

export <variável>

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

export <variável>=<valor>

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

export -p

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.

1.2. Variáveis Especiais

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.

2. Controle de Fluxo

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).

2.1. Condicionais

2.1.1. if

Sintaxe:

if <condicao>
then
    comandos
elif <condicao_2>
    comandos 
else
    comandos 
fi

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 7
then
    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)

2.1.2. case

Sintaxe:

case <string> in
    opcao1)
        comandos 
        ;;
    opcao2)
        comandos 
        ;;
    *)
        operação padrão
esac

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

2.1.3. select

Sintaxe:

select <variavel> in <opcao1> <opcao2> ...
do 
    comandos 
done

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_tree
do
    case "$i" in 
        lista_arquivos)
            ls
            ;;
        lista_arquivos_tree)
            ls -R
            ;;
    esac
done

2.2. Estruturas de Repetição (Loops)

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

2.2.1. for

Sintaxe:

for <var> in <lista>
do
    <comandos>
done

“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 5
do
    echo $i
done

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

for i in $(ls /)
do
    echo $i
done

for i in $(seq 1 10)
do
    echo $i
done

for i in $(cat /etc/passwd)
do
    echo $i
done

2.2.2. while

Sintaxe:

while <condicao>
do
    <comandos>
done

Exemplos:

Exibe a sequência de 1 a 10:

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

Loop infinito que exibe “bash” na tela:

while true
do
    echo 'bash'
done

Lendo strings da entrada padrão:

while read i
do
    echo 'Voce digitou a string: ' $i
done

Exibe as linhas de um arquivo:

cat 'arquivo.txt' | while read i
do
    echo $i
done

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 i
do
    echo $i
done < 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=0
cat $FILE | while read i
do
	total=$((total+1))
done
echo 'Total de linhas: ' $total
 
total=0
while read i
do
	total=$((total+1))
done < $FILE
echo '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)

2.2.3. until…do

Sintaxe:

until <condicao>
do
    <comandos>
done

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

Com while:

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

Com unitl:

i=0
until [ $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.

2.2.4. break

O comando break encerra um loop imediatamente.

Exemplos:

i=0
while true
do
    if [ $i -ge 10 ]
    then
        break
    fi
    i=$((i+1))
done

while read i
do
    if [ $i -eq 0 ]
    then
        break
    fi
done

2.2.5. continue

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.

3. Padrão C/C++ em Expressões “(())”

É 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=0
while (( 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 $i
done

4. Entrada/Saída

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. :)

4.1. Redirecionamento

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″.

$ cat arq1 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).

$ cat 
Ola! Tem alguem ai?  # usuário 
Ola! Tem alguem ai?  # eco do sistema 
Ate mais!            # usuário 
Ate 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:

$ sort 
bananas     # usuário
peras       # usuário
goiabas     # usuário
            # ctrl+d
bananas     # eco do sistema
goiabas     # eco do sistema
peras       # 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 > lista
bananas  # usuário
peras    # usuário
goiabas  # 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 lista
bananas
goiabas
peras

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 >> listagem
ls >> listagem
less listagem

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

4.2. Usando Pipelines

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.

$ ls
historia  notas     tese      testes 
$ ls > lista 
$ sort -r lista 
testes
tese
notas
lista                             # observe esse nome de arquivo
historia

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 -r 
testes
tese
notas
historia

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.

5. Expansões

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:

ls ~

ls ~root

ls /dev/std{in,out,err}

5.1. Expansão de Variáveis

6. Parâmetros de linha de comando

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 = '$0
echo '$1 = '$1
echo '$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

7. Definindo Funções

Sintaxe:

function nome_da_funcao()
{
     <comandos>
}

Para chamar a função:

nome_da_funcao
 
# caso haja parâmetros
nome_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.

7.1. Retorno de Funções

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:

$ cat /etc/passwd
echo $?

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.

8. Expressões Regulares em Bash

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

9. Expressões Matemáticas

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))
...

10. O Arquivo .bashrc

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):

$ vim ~/.bashrc

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

11. Aliases (Apelidos)

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:

alias <nome>=<comando>

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:

$ alias lf='ls -F'

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.

12. Referências

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/

Com o SED é possível substituir e “casar” padrões, sempre por meio de Expressões Regulares, outra grande ferramenta do mundo da Computação.

O SED, assim como o AWK, lê um arquivo, linha por linha, e aplica a expressão do parâmetro a cada uma delas.

A sintaxe do SED é a seguinte:

sed 'expressão' arquivo

É possível filtrar a saída de outro comando, em vez de filtrar um arquivo, usando pipe. Usarei saídas do comando echo para explicar o sed.

SED usa Expressões Regulares (ER’s). Se você não conhece ER’s, sugiro ler o Expressões Regulares – Guia de Consulta Rápida

1. Substituindo textos: comando s
1.1. Escapando o delimitador
1.2. Usando a expressão casada em ER na substituição
1.3 Usando “retrovisores” (\1, \2…)
2. Modificadores
2.1. Modificador “g”: tratar linha inteira
2.2. Modificador “p”: exibir na tela
3. Restringindo por linhas
4. Restringindo por padrões
5. Remover linha: comando d
6. Sair: comando q
7. Adicionando linha: comando “a”
8. Adicionando linha: comando “i”
9. Mudando uma linha: comando c
10. Links

1. Substituindo textos: comando s

Sintaxe: s/ER/sub/[modificadores]: Substitui os padrões “casados” em “ER” por “sub”.

A utilidade mais conhecida do SED é a substituição de textos. Para isso, usamos o comando “s” do sed:

echo "Tutorial sobre sed: aprenda a trabalhar com sed" | sed 's/sed/awk/'

A saída será: Tutorial sobre awk: aprenda a trabalhar com sed. Note que a última ocorrência de “sed” não foi modificada. Isso porque o sed faz a modificação na primeira ocorrência e, em seguida, já procura pelo padrão na linha seguinte, se houver. Para que o sed execute a ação na linha toda, usamos o modificador “g”:

echo "Tutorial sobre sed: aprenda a trabalhar com sed" | sed 's/sed/awk/g'

Agora a saída é a esperada: Tutorial sobre awk: aprenda a trabalhar com awk.

Os modificadores serão abordados com mais detalhes logo mais abaixo. Não percam! =P

1.1. Escapando o delimitador

Como estamos usando a barra (/) como delimitador, se quisermos usar esse caractere na ER ou na substituição, temos de escapá-lo, com barra invertida:

echo "o arquivo /proc/cpuinfo possui informações importantes" | sed 's/\/proc\/cpuinfo/\/etc\/passwd/'

Saída: o arquivo /etc/passwd possui informações importantes

1.2. Usando a expressão casada em ER na substituição

Às vezes queremos acrescentar algo ao texto original. Por isso, é preciso que tenhamos o texto casado na ER. Para isso, usamos o caractere & para nos referirmos à expressão casada pela ER.

Suponhamos que queremos colocar todos os caminhos de arquivos entre aspas. Para isso:

echo -e "o arquivo /proc/cpuinfo possui informações importantes \nEste tutorial está em /home/beraldo/tutoriais. Há muitos outros nesse diretório" | sed -r 's/(\/[^ .,]*)+/"&"/'

Saída:
o arquivo “/proc/cpuinfo” possui informações importantes
Este tutorial está em “/home/beraldo/tutoriais”. Há muitos outros nesse diretório

A opção “-r” usa o padrão estendido de expressões regulares – o mesmo usado por “egrep”. Isso possibilita o uso da lista negada.

1.3 Usando “retrovisores” (\1, \2…)

Muitas vezes queremos substituir partes de um texto, mas manter outras. Para isso, podemos usar os “retrovisores”, que inserem na string final os padrões casados na ER inseridos em grupos (( e )). O primeiro grupo casado é referenciado por \1, o segundo, por \2 e assim sucessivamente, até \9.

Por exemplo, vamos manter apenas a primeira palavra de cada linha do texto:

echo -e "primeira linha\nsegunda linha\nterceira linha" | sed -r 's/^([a-z]+).*/\1/g'

Importante: Para usar os retrovisores, é necessário usar a opção -r do sed, que ativa o padrão estendido de ERs.

2. Modificadores

2.1. Modificador “g”: tratar linha inteira

Já vimos o modificador g anteriormente, que serve para forçar o SED a aplicar a expressão na linha inteira.

É possível associar um número ao modificador “g”, para fazer com que o SED atue apenas a partir de uma determinada ocorrência do padrão.
Por exemplo, vamos substituir por NULL todas as palavraas do texto:

echo "palavra1 palavra2 palavra3" | sed -r 's/([a-zA-Z0-9]+)/NULL/g'

Vamos supor que gostaríamos de remover todas as ocorrências, exceto a primeira. Para isso executaríamos o sed assim:

echo "palavra1 palavra2 palavra3" | sed -r 's/([a-zA-Z0-9]+)/NULL/2g'

O “2″ faz com que a substituição ocorra apenas a partir da segunda ocorrência do padrão.

2.2. Modificador “p”: exibir na tela

Por padrão, o SED imprime na saída padrão todas as linhas lidas – e modificadas. A opção -n impede que o sed faça a impressão das linhas. É nessa situação que o modificador “p” é útil. Quando quisermos imprimir somente as linhas alteradas pelo SED, usaremos o modificador “p”.

echo -e "linha sem números \nLinha com números: 1 2 3 4 5 6 \nLinha com mais números 42 81" | sed -r -n 's/[0-9]+/X/gp'

Serão mostradas apenas as linhas que casaram com o padrão.

Como foi possível ver no exemplo acima, é possível misturar os modificadores.

3. Restringindo por linhas

E possível fazer o SED atuar somente num intervalo de linhas.

Vamos mostrar os dez primeiros usuários do sistema, listando as dez primeiras linhas do arquivo /etc/passwd.

sed -r -n '1,10 s/([^:]+).*/\1/p' /etc/passwd

Note a opção -n e o modificador “p”, para mostrar somente o padrão casado.

É possível usar o caractere $ (cifrão) para se referir à última linha do arquivo:

sed -r -n '1,$ s/([^:]+).*/\1/p' /etc/passwd

4. Restringindo por padrões

Além de restringir por número de linhas, podemos restringer por padrão:

echo -e "esta\né\numa\nlinha\nusada\npara\ntestar\no\ncomando\nsed" | sed  -e '/uma/,/comando/s/[ae]/X/g'

5. Remover linha: comando d

O comando “d” do sed remove linhas.
Vamos remover as dez primeiraas linhas de /etc/passwd:

sed '1,10 d' /etc/passwd

6. Sair: comando q

O comando “q” faz o sed parar após encontrar o padrão

Imprime as dez primeiras linhas de /etc/passwd

sed '10 q' /etc/passwd

Para após encontrar um número:

echo -e "sou uma linha\nsou outra linha\nesta linha tem número 1\nesta já não tem número" | sed -r '/[0-9]+/ q'

7. Adicionando linha: comando “a”

É possível inserir linha após achar um padrão:

Insere linha após uma linha que contenha número

echo -e "sou uma linha\nsou outra linha\nesta linha tem número 1\nesta já não tem número" | sed -r '/[0-9]+/ a Oi. Sou novo aqui'

8. Adicionando linha: comando “i”

Quase igual ao comando “a”, mas insere a nova linha antes da linha casada com o padrão

Insere linha antes de uma linha que contenha número

echo -e "sou uma linha\nsou outra linha\nesta linha tem número 1\nesta já não tem número" | sed -r '/[0-9]+/ i Oi. Sou novo aqui'

9. Mudando uma linha: comando c

Semelhante a “a” e “i”, mas muda a linha que casou com o padrão

echo -e "sou uma linha\nsou outra linha\nesta linha tem número 1\nesta já não tem número" | sed -r '/[0-9]+/ c Fui modificado'

10. Links

http://www.grymoire.com/Unix/Sed.html
http://www.zago.eti.br/script/sed.html
http://www.linuxmanpages.com/man1/sed.1.php
http://guia-er.sourceforge.net/

Veja abaixo um passo-a-passo e um exemplo usando uma instalação manual do Servidor WEB Apache.

Todos os comandos precisam ser executados como root.

Primeiramente, vamos criar um script chamado meuScript em /etc/init.d com uma estrutura semelhante à abaixo:

#!/bin/bash
#
# /etc/init.d/meuScript
 
case "$1" in
    start)
        echo "Iniciando serviço..."
        # comando para iniciar o serviço
        ;;
 
    stop)
        echo "Parando serviço..."
        # comando para parar o serviço
        ;;
 
    restart)
        echo "Reiniciando serviço..."
        # comando para reiniciar o serviço
        ;;
 
    *)
        echo "Operação inválida"
        ;;
esac

Dê permissão de execução para o script:

# chmod +x meuScript

A partir desse momento você já pode executar os comandos abaixo:

# /etc/init.d/meuScript start
# /etc/init.d/meuScript stop
# /etc/init.d/meuScript restart

Para inserir o script na inicialização do sistema, usamos o comando update-rc.d da seguinte maneira:

# update-rc.d meuScript defaults

O “meuScript” é o nome do script em /etc/init.d, não o caminho completo a ele, ou seja, não importa em qual diretório você está, apenas coloque o nome do script.

O “defaults” indica que desejamos inserir o script nos runlevels padrões do sistema.

Ao executar esse comando, um warning será mostrado, apesar de o comando ter funcionado. Aparecerá uma mensagem como esta:

“update-rc.d: warning: /etc/init.d/meuScript missing LSB information
update-rc.d: see <http://wiki.debian.org/LSBInitScripts>”

Você pode ignorá-lo ou inserir as informações de LSB, o que é mostrado no link exibido no warning. É algo bem simples. =)

Para remover um script da inicialização:

# update-rc.d -f meuScript remove

Como prometi, vou mostrar um exemplo que uso para uma instalação manual do Apache:

#!/bin/bash
#
# /etc/init.d/apache2 
 
### BEGIN INIT INFO
# Provides:          apache2
# Required-Start:    $local_fs $syslog
# Required-Stop:     $local_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Start Apache at boot
# Description:       Start Apache HTTP Server
### END INIT INFO
 
# Path to Apache controller
BIN=/usr/local/apache2/bin/apachectl
 
function startApache()
{
	echo "Starting Apache..."
	$BIN start
}
 
function stopApache()
{
	echo "Stopping Apache..."
	$BIN stop
}
 
case "$1" in
	start )
		startApache
		if [ $? -eq 0 ]
		then
			echo "OK."
		fi
 
		;;
 
 
	stop )
		stopApache
		if [ $? -eq 0 ]
		then
			echo "OK."
		fi
 
		;;
 
	restart )
		stopApache
		sleep 1
		startApache
		if [ $? -eq 0 ]
		then
			echo "OK."
		fi
 
		;;
 
 
	* )
		echo "Invalid option"
		;;
esac

1. Modos de trabalho do Vi
2. Salvando arquivos e saindo do editor
3. Movimentando o cursor
4. Navegação no texto
5. Movimentando textos
6. Apagando texto
7. Copiando e colando textos
8. Desfazendo ações
9. Localizando textos
10. Localizando e substituindo textos
11. Executando comandos no Shell sem sair do Vi
12. Inserindo no texto a saída de um comando Shell
13. Facilidades para programadores e desenvolvedores
14. Configuração do ambiente (comando set

1. Modos de trabalho do Vi

O Vi possui dois modos de trabalho: modo de inserção e modo de comando. Ao ser iniciado, o programa estará sempre em modo de comando. Para alternar do modo de comando para o modo de inserção, há duas maneiras:

a -> Ao pressionar a tecla “a”, o modo de inserção é ativado e o cursor de texto é posicionado logo após o caractere corrente;
i -> Ao pressionar a tecla “i”, o modo de inserção é ativado e o cursor de texto é posicionado à esquerda do caractere corrente.

Para alternar do modo de inserção para o modo de comando, basta pressionar a tecla “ESC”.

2. Salvando arquivos e saindo do editor

Entrar no Vi é fácil. Sair, à primeira vista, é um dilema, podendo causar claustrofobia digital. :P
Os seguintes comandos devem ser executados em modo de comando, claro.

:w -> salva o arquivo corrente. É possível passar um argumento, para definir o nome do arquivo. Por exemplo: :w arq1.txt
ZZ -> salva o documento e sai do Vi. É conhecido como o comando “Zalva e Zai”. :)
:wq -> Salva o arquivo e sai do Vi
:w! -> O arquivo será salvo mesmo se aberto no modo somente leitura (readonly)
:q -> Sai do Vi. Se o arquivo não foi salvo, o programa emitirá um alerta.
:q! -> Força a saída, mesmo que o arquivo tenha sido modificado e não tenha sido salvo anteriormente

Os comandos “:wq” e “ZZ” fazem praticamente a mesma coisa. Porém, “ZZ” é mais rápido de se digitar e mais fácil de lembrar (Zalva e Zai!). ;)

3. Movimentando o cursor

Isso parece fácil. Basta usar as setas. Mas e se você estiver num teclado sem as teclas das setas? Pode parecer jurássico, mas pode acontecer. Nesse caso, use os seguintes comandos:

h -> Desloca para a esquerda
j -> Desloca para baixo
k -> Desloca para cima
l -> Desloca para a direita

É possível digitar um número antes desses comandos, informando o número de deslocamentos desejado.

4. Navegação no texto

[n]$ -> Move o cursor para o fim da linha. Se especificado um número antes do “$” (cifrão), move para o final da linha com o número especificado (a linha corrente é 1; a conseguinte é 2 e assim sucessivamente)
^ -> Move o cursor para o início da linha corrente. Se o teclado for ABNT ou similares, com teclas para acentuação, você terá de digitar a tecla duas vezes, para o Vi compreender o comando literalmente, não como um acento para outra letra.
0 (número zero) -> Equivale ao comando “^”.
[n]A -> Move o cursor para o fim da linha e entra em modo de inserção. É possível inserir um numero antes do “A”, como no comando “$”.
[n]G -> Se não for especificado o número “n”, o cursor será movido para o fim do arquivo. Caso contrário, desloca o cursor para a linha “n”.

5. Movimentando textos

OBS: ^LETRA corresponde à combinação das teclas CTRL e a letra especificada.

^e -> Move o texto para cima, independentemente da posição do cursor.
^y -> Move o texto para baixo, independentemente da posição do cursor.

6. Apagando texto

[n]x -> Apaga o caractere sob o cursor. É possível especificar o número de caracteres a serem removidos.
[n]X -> Apaga o caractere à esquerda do cursor. É possível especificar o número de caracteres a serem removidos.
[n]dd -> Apaga a linha corrente. É possível especificar o número de linhas a serem removidas após a linha corrente.
D -> Apaga todos os caracteres da posição corrente até o final da linha.
d$ -> Equivale ao comando “D”.
d^-> Apaga todos os caracteres da posição corrente até o início da linha.
dw -> apaga os caracteres da posição corrente até o final da palavra.

7. Copiando e colando textos

Para copiar uma linha de textos, usamos o comando “yy”. É possível usar “[n]yy” para definir o número de linhas a serem copiadas.

Para colar o texto copiado, usa-se “[n]p” para colar à direita do cursor ou “[n]P” para colar à esquerda do cursor. O número “n” (opcional) determina o número de vezes que o texto será colado.

8. Desfazendo ações

Não existe o famoso CTRL+Z no Vi. Mas há como desfazer comandos.

u -> Desfaz o último comando
U -> Desfaz todos os comandos executados na linha corrente

9. Localizando textos

/texto -> Busca pela ocorrência da palavra “texto” a partir da posição corrente do cursor até o fim do arquivo.
?texto -> Busca pela ocorrência da palavra “texto” a partir da posição corrente do cursor até o início do arquivo.
n -> Repete o último comando de busca (next)

10. Localizando e substituindo textos

Os comandos abaixo assemelham-se à sintaxe dos comandos de substituição do sed.

:s/busca/troca -> Encontra a primeira ocorrência de “busca” e a modifica para “troca”, na linha corrente.
:s/busca/troca/g -> Faz a mesma coisa que o comando acima, porém o executa em toda a linha.

É possível definir o intervalo de linhas onde a busca será feita, da seguinte forma:

:inicio,fims/busca/troca.

Por exemplo:

:1.42s/busca/troca -> Executa a troca no intervalo das linhas 1 a 42
:..42s/busca/troca -> Executa a troca a partir da linha atual até a linha 42
:..$s/busca/troca -> Executa a troca a partir da linha atual até o fim do arquivo

A busca pode ser feita usando Expressões Regulares.

11. Executando comandos no Shell sem sair do Vi

Para executar um comando no shell sems air do Vi, basta proceder da seguinte forma:

:! comando_shell

Por exemplo:

:! ls -l

12. Inserindo no texto a saída de um comando Shell

O comando anterior executa uma ação no Shell, mas descarta a saída. Se você pretende inserir a saída do comando no texto que está editando no Vi, basta proceder assim:

!! comando_shell

Por exemplo

!! ls -l

13. Facilidades para programadores e desenvolvedores

Indentação

Para inserir indentação, primeiro devemos definir o tamanho da tabulação, usando o comando :set (mais a frente detalharei esse comando).

:set sw=n

Onde “n” é o tamanho da tabulação.

Feito isso, poderemos utilizar os seguintes comandos:

[n]>> -> Indenta n linhas (ou apenas a linha corrente se “n” for omitido)
[n]<< -> Retira a indentação de n linhas (ou apenas da linha corrente se “n” for omitido)

Correspondência entre parênteses, colchetes e chaves

Com o cursor sobre um sinal de parênteses, colchete ou chave, execute o comando “%”. Se houver um caractere correspondente, o cursor será movido para ele.

14. Configuração do ambiente (comando set

:set <opcão> -> Ativa <opção>
:set no<opção> -> Desativa <opção>
:set <opção>=<valor> -> Define <valor> à <opção>
:set <opção>? -> Exibe o valor de <opção>
:set all -> Exibe todas as opções

Algumas opções do comando set:

ai -> Autoindent. Indentação automática
ic -> Ignore case. Ignora maiúsculas e minúsculas numa busca.
nu -> Numeração de linhas
sw -> shift width. Tamanho da tabulação
sm -> show match. Ao fechar um parêntese, colchete ou chave, o Vi mostra onde ele foi aberto. Caso não haja correspondência, um bip será emitido.

Para não precisar definir todas essas configurações sempre que iniciar o Vi, você pode criar um arquivo de configuração. O Vi busca no arquivo ~/.exrc (arquivo oculto exrc na home do usuário) as configurações iniciais. Logo, você pode criar um arquivo assim:

set sw=4
set ai
set nu

Links interessantes:
Vim Editor : 100 commands every admin should know

AWK é uma linguagem utilizada para processamento de informações em texto, como o conteúdo de um arquivo – principalmente informações em colunas – ou a saída de outros comandos, como cat, grep etc.

A estrutura de um script AWK (pode estar em um arquivo ou ser escrito diretamente na linha de comando – Shell) é a seguinte:

1
2
3
4
5
6
7
8
9
10
11

BEGIN{
 Comandos executados ao iniciar o processamento, antes de ler as linhas do texto
}
 
[condicao]{
 Comandos a serem executados em todas as linhas do texto
}
 
END{
 Comando final. Executado após o processamento de todas as linhas
}

A condição do segudo bloco é opcional. Se não especificada, os respectivos comandos do bloco serão executados em todas as linhas. Caso contrário, serão executados apenas nas linhas que satisfizerem a condição.
A condição pode ser uma expressão regular. Basta colocá-la entre barras:

1
2
3

/^A/{
 Comando...
}

Se um bloco de comandos estiver vazio, é executado print $0, ou seja, imprime a linha corrente.

Algumas variáveis definidas no AWK:

FS -> separador de campos
NR -> número da linhas
NF -> número de campos na linha

Para mais informações:

Manpage do AWK: $ man awk
http://www.gnu.org/software/gawk/manual/gawk.html
http://en.wikipedia.org/wiki/Awk

Exemplos:

Filtra as linhas com o padrão especificado. Linhas que terminam com conf

1

ls -l /etc | awk /conf$/

Usando outro separador de campos e imprimindo colunas

1

cat /etc/passwd | awk -F: '{print $1}'

Usando separador de campos

1

ls -l /etc |awk '{print $1 FS $8}'

Numerando linhas

1

ls -l /etc | awk '{print NR FS$1 FS $8}'

Filtra linhas com padrão especificado e mostra apenas as colunas 1 e 8.

1

ls -l /etc | awk '/conf$/{print $1" "$8}'

Imprime as linhas com mais de 3 campos. Elimina a primeira linha do ls -l (Total)

1

ls -l /etc | awk 'NF > 3'

Filtra linhas com arquivos cujos nomes possuem menos de 5 caracteres

1

ls -l /etc | awk 'length($8) < 5'

Imprime linhas pares

1

ls -l /etc | awk 'NR % 2 == 0 {print NR" "$0}'

Substitui strings

1

ls -l /etc | awk '{sub(/conf$/,"test"); print $0}'

Procura expressão em determinado campo

1

ls -l /etc | awk '$8 ~ /^[ae]/'

Inserindo strings entre campos

1

cat /etc/passwd | awk -F: '{print "Login: " $1}'

Filtra a saída de ls -l, a fim de mostrar o nome do arquivo, suas permissões e seu tamanho (a condição NR != 1 evita que a linha Total seja exibida):

1

ls -l | awk 'NR != 1{print "Nome: "$8" Perm: "$1" Tamanho: "$5}'

Imprime o comprimento da maior linha

1

awk '{ if (length($0) > max) max = length($0)}; END { print max}'; arquivo

Imprime as linhas com mais de 42 caracteres

1

awk 'length($0) > 42' arquivo

Exibe o número de linhas do arquivo

1

awk 'END { print NR }' arquivo