Shell on Peczenyj's Blog

Tabela do Brasileirão 2008 com links + sed

Wed, 18 Jun 2008 15:15:00 -0300

O sed é um processador de texto muito versátil.

O links é um browser modo texto com features tão interessantes quanto do antigo lynx.

Ano passado eu postei como imprimir a tabela do brasileirão com um one liner interessante. Agora eu resolvi beber de outra fonte:

#!/bin/bash
TIME=Internacional
COLOR=$(echo -ne '\e[31;1m&\e[m')
URL=http://globoesporte.globo.com/Esportes/Futebol/Classificacao/0,,ESP0-9827,00.html
links --dump ${URL} | sed -r 's/\[[0-9]*\]//;/(^[0-9]|J jogos)/!d' | sed "s/${TIME}/${COLOR}/
 1a-----Libertadores----------
 4a-----Pre-Libertadores------
 5a-----Sul-Americana---------
 13a---------------------------
 17a-----Rebaixado-------------"

O resultado não é tão bom quanto o do ano passado, é verdade, mas não deixa de ser uma alternativa

Comments

Alan Carvalho de Assis

Ola Tiago,
gostei do script, muito fera.

Um abraço,

Alan

Tiago Peczenyj

Dê tempo ao tempo... ;-)

Ivan Brasil Fuzzer

Com poucas alterações no script até o resultado melhora.
Os bugs encontrados estão na cor e no time!
Mudando para azul e Gremio fica bem melhor :-P

Abraços.

Pesquisando nos Grupos do Yahoo

Wed, 28 May 2008 18:17:00 -0300

Meu amigo MrBits me deu essa grande ideia:

#!/bin/bash
QTDE=20
CHARSET=UTF-8
GROUP=shell-script

while getopts g:c:q: OPTION ; do
 case $OPTION in
 g) GROUP=$OPTARG ;;
 c) CHARSET=$OPTARG ;;
 q) QTDE=$OPTARG ;;
 esac
done

shift $(($OPTIND -1))

SEARCH="$@"

if [ -z "$SEARCH" ]; then 
 echo "Usage: $(basename $0) [-q qtde] [-g grupo] [-c charset] search" 
 exit 1
fi

BASEURL="http://br.groups.yahoo.com/group"
URL="${BASEURL}/${GROUP}/msearch?submit=OK&charset=${CHARSET}&cnt=${QTDE}&query=${SEARCH// /+}" 
SEDCMD="/message/!d;/${GROUP}/!d;/.*[0-9]/!d;s#/group#${BASEURL}#g;s/<[^>]*span>//g;s/$/<br \/>/"

LYNXOPT="-dump -force_html -assume_charset=${CHARSET}"
lynx $LYNXOPT <( curl -b /tmp/cookie$$ -sL "${URL}" | sed "${SEDCMD}" )

Vejamos em uso:

$ ./find.sh 
Usage: find.sh [-q qtde] [-g grupo] [-c charset] search

$ ./find.sh -q 10 getopts # procurando por getopts limitando a 10 registros
 [1]Re: [shell-script] Script de busca de mensagens
 [2]Re: [shell-script] Re: script iterativo / passo a passo
 [3]Re: [shell-script] Script de Backup
 [4]Re: [shell-script] Script de Backup
 [5]Re: [shell-script] Script de Backup
 [6]Re: [shell-script] Script de Backup
 [7]Re: [shell-script] Echo e executa: superecho
 [8]Re: [shell-script] testar se parametro $1 foi passado
 [9]Re: [shell-script] Echo e executa: superecho
 [10]Re: [shell-script] testar se parametro $1 foi passado

References

 1. http://br.groups.yahoo.com/group/shell-script/message/26373
 2. http://br.groups.yahoo.com/group/shell-script/message/26204
 3. http://br.groups.yahoo.com/group/shell-script/message/26078
 4. http://br.groups.yahoo.com/group/shell-script/message/26076
 5. http://br.groups.yahoo.com/group/shell-script/message/26075
 6. http://br.groups.yahoo.com/group/shell-script/message/26072
 7. http://br.groups.yahoo.com/group/shell-script/message/25742
 8. http://br.groups.yahoo.com/group/shell-script/message/25720
 9. http://br.groups.yahoo.com/group/shell-script/message/25719
 10. http://br.groups.yahoo.com/group/shell-script/message/25718

Divertido, não? o default é procurar no grupo shell-script do yahoo, mas ele pode investigar em qualquer um.

Valeu Mr.Bits!!

Comments

Tiago Peczenyj

Hahaha... te amarrou, gc?

Podes usar pra pesquisar no rioguj ;-)

Guilherme Chapiewski

\o/

É por isso que bash é a melhor coisa de todo o universo!!!

Tiago Peczenyj

Mas é facil, Roger!

/padrão/!d -> apaga *todas* as linhas que *não* casam com o padrão

s/padrão/substituição/g -> substitui, globalmente, o padrão pela substituição

s#xxx#yyy#g -> mesma coisa, util para não ter que escapar o caracter /

Roger Leite

Putz Tiago ! Você tá ficando muito louco mesmo, deve ser o sol ai do Rio ... não é possível !

Estes comandos de sed são de arrepiar, um dia ainda vou entender isso "nativo".

flw e sucesso!

Tiago Peczenyj

VB ? NUNCA!!!

Mas ja fiz coisas com VBScript... :$

Marcelo Martins

Tiago, tu ta ficando cada vez pior cara. Já pensou em dar um tempo e programar um pouco em Visual Basic?

hehe.. muito bom!

Manipulando logs com AWK e SED

Sat, 26 Apr 2008 14:41:00 -0300

Eis que a lista de shell script traz um bom desafio.

Galera, tenho o seguinte log.:

AAAA-------------campo_1-------------campo_2-----campo_3----campo_4----------
teste_1 371508787 371547453 38666 testetesteteste

BBBB-------------campo_1-------------campo_2-----campo_3----campo_4----------
teste_2 4625081503 4651313710 26232207 testetesteteste

Estou a tentar usar o awk com a seguinte função :
awk '$1~"teste_" {print $5";"$4}' teste > teste_.csv

a funcao busca realmente o que desejo:
$5 $4
testetesteteste 38666
testetesteteste 6232207

porem,, gostaria que seprasse da forma:

AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

Alguém tem uma dica de como fazer?

Ah... o bom e velho SED pode resolver isso

$ sed -rn '/(^[^-]+-+).*/{s//\1/;h};
/^teste_/{s/.* ([^ ]+) +([^ ]+$)/\2 \1/;x;p;g;p}' arquivo.log
AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

Ok, ok, ta muito complicado, mas veja só:

$ sed -rn '/^[^-]+-+/h;/^teste_/{x;p;g;p}' arquivo.log 
AAAA-------------campo_1-------------campo_2-----campo_3----campo_4----------
teste_1 371508787 371547453 38666 testetesteteste
BBBB-------------campo_1-------------campo_2-----campo_3----campo_4----------
teste_2 4625081503 4651313710 26232207 testetesteteste

Vamos explicar
1) a opção -n serve para informar ao sed "imprima apenas quando eu mandar"
2) a opção -p serve para utilizar expressões regulares extendidas
(assim não preciso escapar o quantificador + , que significa "um ou
mais vezes", assim como os parentesis, para informar os grupos).

Eu fiz uma sacanagem. o comando h quarda o padrão num espaço chamado espaço reserva, tipo uma memória do sed, sobreescrevendo. Assim no espaço reserva eu tenho a ultima ocorrencia de uma linha do tipo, ^[^-]+-+ ,que traduzindo significa: tudo o que começa com um ou varios caracteres diferentes de -, seguidos de um ou varios - (no caso
do AAAA------------- ... ).

Agora, quando eu encontro uma linha que começa com teste_ eu:

x) troco essa linha com a linha que esta na memória (a atual
'teste_...' vai, outra volta).
p) imprimo a linha que veio (AAAA---------- ...)
g) pego a linha da memória (teste_...)
p) imprimo a linha cachorrona

Só que não fica como vc quer. Ai vc precisa fazer a sacanagem:

se uma linha NÃO tem o que eu quero, então eu a manipulo habilmente
até que ela chegue ao que eu quero

Eu poderia ter usado varias tecnicas mas... uma vez com sed, podemos continuar nele.

$ sed -rn '/(^[^-]+-+).*/{s//\1/;h};
/^teste_/{s/.* ([^ ]+) +([^ ]+$)/\2 \1/;x;p;g;p}' arquivo.log

eu transformei a primera ER em (minha_ER).* -- ou seja, criei um grupo para o que me interessa. basta fazer:

s/(minha_ER).*/\1/

para que toda a linha seja reduzida ao que a minha ER casa. em outras palavras, eu apaguei o resto da linha.

na outra eu fui mais sacana pois eu tenho 2 grupos e troco toda a linha pelos grupos, na ordem inversa. coisa de quem toma muito café e não tem escrupulos.

Vamos ver a versão AWK?

$ awk '/^[^-]+-+/{match($0,/^[^-]+-+/); x=substr($0,1,RLENGTH)}
/^teste_/{print x,"\n"$5,$4}' arquivo.log
AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

x, nesse caso, armazena aquele pedaço da linha anterior, que eu descobri o que é via match. match procura uma expressão regular numa string, nesse caso em $0, e seta um valor na variavel RLENGTH, que é onde a expressão acaba. basta pegar essa parte da string e guardar na variavel x, que sera lida depois.

Aqui fala um pouco dessas duas funções: http://people.cs.uu.nl/piet/docs/nawk/nawk_92.html

Eu poderia ter resolvido dessa forma também

$ awk '/^[^-]+-+/{sub(/-[^-]+.*$/,"-");x=$0} 
/^teste_/{print x,"\n"$5,$4}' arquivo.log
AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

Entretanto aqui eu faço uma substituição grosseira do resto da linha que tem o AAAA------... por -, abusando do .* (e o fato dele ser guloso). Parece mais simples, mas está sujeito à falhas, embora não consigo pensar em nenhuma situação que seja possivem demonstrar.

AWK & SED são ferramentas sensacionais para esse tipo de problema ;-)

Comments

blpsilva

Impressive, to say the least :)

Acho que chegou a hora de limpar a minha ferrugem e reler o Advanced Bash Scripting Guide.

You produce some quite nice pearls inside the shell ;)

Tiago Peczenyj

grep + awk + sed:

$ grep -B 1 teste_ arquivo.log | \
awk '/teste_/{print $5,$4; next} 1' | \
sed -r '/^--$/d;s/(^[^-]+-+)[^-].*/\1/'

AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

Um corretor ortográfico em gawk

Sun, 13 Apr 2008 14:39:00 -0300

Ano passado eu publiquei uma pequena nota sobre um pequeno corretor ortográfico feito em Python.

No artigo do Peter Norwig, ele explica o principio estatístico do algoritmo. No final, ele mostra varias implementações do algoritmo (em D, Java, Ruby e até Erlang).

Depois de muito pesquisar, decidi fazer uma versão em gawk. A primeira tinha 30 linhas e não funcionava muito bem, arrumando e testando cheguei a esta forma final com apenas 15 linhas.

Eu chamo de linha um statement completo do awk. Perceba que nenhuma linha dessas possui o separador de statement ; (ponto-e-virgula), exceto quando estou utilizando o for no estilo C.

# Usage: gawk -v word=something -f thisfile.awk [ big.txt [ big2.txt ... ]]
# Gawk version with 15 lines -- 04/13/2008
# Author: tiago (dot) peczenyj (at) gmail (dot) com 
# Based on : http://norvig.com/spell-correct.html
function edits(w,max,candidates,list, i,j){
 for(i=0;i< max ;++i) ++list[substr(w,0,i) substr(w,i+2)] 
 for(i=0;i< max-1;++i) ++list[substr(w,0,i) substr(w,i+2,1) substr(w,i+1,1) substr(w,i+3)] 
 for(i=0;i< max ;++i) for(j in alpha) ++list[substr(w,0,i) alpha[j] substr(w,i+2)] 
 for(i=0;i<= max ;++i) for(j in alpha) ++list[substr(w,0,i) alpha[j] substr(w,i+1)] 
 for(i in list) if(i in NWORDS) candidates[i] = NWORDS[i] }

function correct(word ,candidates,i,list,max,temp){
 edits(word,length(word),candidates,list)
 if (!asort(candidates,temp)) for(i in list) edits(i,length(i),candidates)
 return (max = asorti(candidates)) ? candidates[max] : word }

BEGIN{ if (ARGC == 1) ARGV[ARGC++] = "big.txt" # http://norvig.com/big.txt
 while(++i<=length(x="abcdefghijklmnopqrstuvwxyz")) alpha[i]=substr(x,i,1)
 IGNORECASE=RS="[^"x"]+" }

{ ++NWORDS[tolower($1)] }

END{ print (word in NWORDS) ? word : "correct("word")=> " correct(tolower(word)) }

Veja o script em funcionamento:

$ time gawk -v word=somethink -f spelling.awk
correct(somethink)=> something

real 0m4.862s
user 0m4.702s
sys 0m0.093s

Comments

Rael

Tiago, mais uma vez, parabéns!
É muito divertido mexer com estas coisas, não?
Ah, eu não esqueci de te mandar a versão otimizada em Java... eu só não achei seu email pra enviar! :P
Me manda um email, e eu te dou reply!

Tiago Albineli Motta

Corretor ortográfico, tatuagem... esse foi um final de semana divertido pra você heim! hahahha

Hackeando um Hello World com sed

Fri, 28 Mar 2008 17:55:00 -0300

Fantástico o que o sed pode fazer!

$ cat a.c
main(){ 
 puts("hello world"); 
}
$ gcc a.c
$ ./a.out 
hello world
$ sed -i 's/hello world/_ola mundo_/'./a.out 
$ ./a.out 
_ola mundo_

Alterando Multiplos Arquivos (versão final?)

Fri, 22 Feb 2008 19:27:00 -0300

O site Dicas-L trouxe na ultima semana 2 formas de renomear multiplos arquivos (aqui e aqui)

#Forma 1
for o in $(ls -1 *.txt); do
 mv $o $(echo $o | awk -F. '{print $1".htm"}');
done

#Forma 2
for i in `ls *.txt`; do
 mv $i $(echo `basename $i .txt`.html)
done

São ambas formas interessantes, porém ao meu ver consomem muito recursos da maquina, sem falar que são um tanto... feios... (nada contra - o que importa é que funcione)

Vou utiliza-los como exemplo de como podemos tornar algo melhor e mais prático (se o tempo permitir).

Vamos dividir as paradas:

altera() { mv $1 $(echo `basename $1 .txt`.html) ; }

for i in `ls *.txt`; do
 altera $i
done

Agora vamos tomar um cuidado: arquivos com espaço no nome

altera() { mv "$1" $(echo `basename "$1" .txt`.html) ; }

for i in `ls *.txt`; do
 altera "${i}"
done

Bom, o for pode iterar sobre uma lista de argumentos. As mascaras de nome de arquivo são expandidos pelo shell durante a execução, logo...

for i in *.txt ; do
 altera "${i}"
done

Agora, a rotina de alteração do nome do arquivo de destino é complicadissima, depende de um ou mais sub-processos. Isso poderia ser...

altera() { mv "$1" "${1%.txt}.html" ; }

Que, inserido no for...

for i in *.txt ; do
 mv "${i}" "${i%.txt}.html"
done

Interessante, certo? Nenhum sub-processo, exceto o inumeros mv que serão executados. Existem outras formas de fazer a mesma coisa

ls *.txt | awk -F. -v OFS=. '{ O=$0; $NF="html" ;printf "\"%s\" \"%s\"\n",O,$0 }' | xargs -n 2 mv

ls *.txt | sed 's#^\(.\+\)\.[^.]\+$#"&" "\1.html"#g' | xargs -n 2 mv

(rodem as linhas acima sem o mv do xargs para entende-las -- é metaprogramação)

Agora... tudo isso é muito bonito mas... veja se o seu computador possui os comandos mmv ou rename (que facilitam Absurdamente a tarefa)

rename .txt .html *.txt

mmv "*.txt" "#1.html"

Simples, não?

Tudo depende do tempo que temos e das nossas necessidades. Mesmo que o rename/mmv sejam uteis, pode ser que a forma com awk / sed valha mais a pena pois o ls pode ser substituido por um find (ja pensou nisso?)

Comments

Leonardo Bernardes

Já conhecia o NF, depois de conhecê-lo queimei um pouco a cabeça tentando elaborar um método pra fazer essa passagem do 1 ao NF. Pensei em qualquer coisa semelhante ao while.. mas não veio nada.

Na verdade, Tiago, sou um belo amador, brinco de fazer scripts como terapia.. terapia que eu realizava aos montes na época de mIRC.

Por conta mesmo do meu amadorismo, não consegui entender seu exemplo de como queimar os registros intermediários. Mas não esquente com isso, se não há aquela variável mágica que eu usava no mIRC, é melhor que eu me contente com minhas limitações. Em todo caso, fico ligado nas suas dicas da seção shell.

Tiago Peczenyj

Ola Leonardo.

Infelizmente o gawk não tem o conceito de range. Quando vc utiliza o operador $X vc esta pegando o X-ésimo campo daquele registro. Vc tem uma variavel que é setada a cada registro que é NF, o numero de registros, que permite que vc leia o ultimo registro de forma simples

print $1,$NF

Agora... tem uma sacanagem que vc pode fazer: $0 é o registro inteiro, porém vc pode "queimar" alguns registros intermediarios

no seu caso, se vc fizesse

$3=$4=$5=$6=""
print $0

só sobraria o que vc quer.

Uma forma, menos agressiva, seria tentar pegar um padrão via expressões regulares.

Leonardo Bernardes

Tiago,

Você parece o sujeito certo pra esclarecer um dúvida:

Se eu quiser filtrar uma string do seguinte tipo

7718 0.0 0.0 1756 476 ? Ss 17:59 0:00 /bin/sh -c pidgin

Como AWK eu posso fazer através de algo como "awk '{print $1,$2,$10}'"

Mas se eu quiser, por exemplo, filtrar o $1, o $2 e todos OS DEMAIS após o $7 sem saber o número total de termos, há alguma variável pra isso? Não sei se me fiz entender, mas essa dúvida me persegue desde que lembrei que quando eu brincava editando scripts no mIRC, uma simples $7- realizava essa função

Desculpe o abuso, abraços

Twitter.sh versão 2.0

Wed, 30 Jan 2008 09:02:00 -0300

O Bruno me deu uma ótima sugestão: um simples usage.

Entretanto ontem eu fiquei batendo cabeça com os inúmeros tac/tail's mas percebi q um sed resolvia a questão. Alias é possivel também passar uma lista de parâmetros também!

#!/bin/bash
TWIURL=http://m.twitter.com # utilizando versão 'mobile' do twitter
USAGEMSG="Usage: $(basename $0) <twitter-user> [user list...]"

[ -z "$1" ] && { echo "${USAGEMSG}" ; exit 1 ; }
for i in "$@" ; do
 echo "==============================="
 links -dump "${TWIURL}/${i}" | sed -r '1,3d;/^\ +Older [0-9]+/,$d'
done

Agora chega :)

Comments

Tiago Peczenyj

Oi Paulo,

O Gabriel Stein me deu uma ótima ideia de como postar no twitter:

http://gabrielstein.org/?p=181

Estou pensando em fazer um script simples para ler e postar no twitter e isso pode evoluir para muita coisa :) Se quiser colaborar ou indicar como eu poderia divulgar mais, sinta-se à vontade.

Paulo Diovani

Script interessante.
Já pensou em fazer algum widget para desktop com ele? Ou quem sabe divulgar em alguma comunidade internacional para alguém fazê-lo.

AWK e Arrays Associativos

Wed, 31 Oct 2007 13:09:00 -0300

Um grande problema para quem trabalha com arrays associativos no AWK é
com relação a ordem dos elementos quando esta fazendo uma iteração.

Ex:

$ gawk 'BEGIN{ split("5 4 2 1 3",T) ; for(i in T) print T[i]}'
1
3
5
4
2

Eu inseri, nessa ordem, 5, depois 4, depois 2... porém o acesso aos
elementos de um array em um for do tipo

for( variavel in array)

é imprevisive / incontrolável.

Agora vejamos isto:

$ WHINY_USERS=1 gawk 'BEGIN{ split("5 4 2 1 3",T) ; for(i in T) print T[i]}'
5
4
2
1
3

WOW! Através da variavel de ambiente do unix WHINY_USERS agora eu consigo acessar os elementos na ordem em que eles foram inseridos no array!

E para acessar os valores na ordem crescente:

$ WHINY_USERS=1 gawk 'BEGIN{ split("5 4 2 1 3",T)
 asort(T) ; for(i in T) print T[i] }'
1
2
3
4
5

A variavel de ambiente WHINY_USERS não esta documentada no man, muito menos na documentação que consegui a respeito do gawk. Descobri esta dica no comp.lang.awk e, por incrivel que pareça, tive que vasculhar o codigo fonte do gawk (graças a deus podemos fazer isso) para entender melhor o que essa variavel poderia fazer.

Enfim, fica a dica.

Convertendo Números

Mon, 01 Oct 2007 19:29:00 -0300

Um dos meus primeiros desafios na área de programação foi fazer um conversor de números decimais para romanos. Eu estava aprendendo Turbo Pascal e usava um potente 286 com 1MB de memória - sem HD.

Fiz a maior sequencia de ifs da minha vida. Hoje estava relembrando e resolvi fazer uma versão SED.

/[0-9]*[5-9]...$/q
s/1...$/M&/;s/2...$/MM&/;s/3...$/MMM&/;s/4...$/MMMM&/
s/6..$/DC&/;s/7..$/DCC&/;s/8..$/DCCC&/;s/9..$/CM&/
s/1..$/C&/;s/2..$/CC&/;s/3..$/CCC&/;s/4..$/CD&/;s/5..$/D&/
s/6.$/LX&/;s/7.$/LXX&/;s/8.$/LXXX&/;s/9.$/XC&/
s/1.$/X&/;s/2.$/XX&/;s/3.$/XXX&/;s/4.$/XL&/;s/5.$/L&/
s/1$/I/;s/2$/II/;s/3$/III/;s/4$/IV/;s/5$/V/
s/6$/VI/;s/7$/VII/;s/8$/VIII/;s/9$/IX/
s/[0-9]//g

Tendo um número por linha ja basta.

$ echo '3999' | sed -f other.sed
MMMCMXCIX

O sed é realmente fantástico! Pena que acima de 5 mil tem que colocar uma barra em cima dos números.

Comments

voyeg3r

Também sou super fã do SED, estou no momento criando um script para converter um wiki do pbwiki para moinmoin, são mais de 300 páginas e adição manual seria um trabalho digno para um usuário windows :)

Metaprogramação com awk e sed

Tue, 28 Aug 2007 15:17:00 -0300

Criar um programa que cria programas é simples nas linguagens interpretadas.

Criamos o programa em uma string e executamos via eval() ou então gravamos em arquivo e executamos novamente.

Me deparei com o seguinte problema: inverter as palavras de uma frase ou arquivo mantendo a ordem em que aparecem.

É claro que eu pensei em usar o rev, mas ele inverte a linha como um todo. Depois de fazer um laço for muito feio em awk, fiquei pensando em como resolver de forma mais legível.

Tive esta ideia: vou fazer uma lista de palavras, inverte-las com o rev e, para cada palavra, vou substitui-la pela palavra invertida. Beleza, o sed faz isso com um pé nas costas.

Eu tenho um arquivo (poderia ser um named pipe) chamado 'direito' que contem uma lista de palavras sem repetição, com uma palavra por linha. Outro arquivo, com o mesmo conteudo mas revertido via 'rev'.

Uso o paste para colocar os arquivo lado a lado e uso o awk para gerar comandos como este:

s/\bpalavra\b/palavra_revertida/g;

Usei o awk pq a sintaxe fica mais clara, o sed ficou muito poluído. Perceba que eu uso o recurso de borda das expressões regulares. Isso me garante que vou trocar uma palavra inteira, e não um pedaço da string.

Agora vem o pulo do gato: mando estes comandos via stdin para o sed, fazendo uso de um pipe. eu informo para o sed que os comandos virão pela stdin passando a opção -f -

Vejam o resultado abaixo, espero que seja útil para alguem :)

$ cat stuff
Nosso fórum principal.

Problemas com hardware em geral,

temperaturas, comparação de desempenho,

compatibilidades de componentes, etc.

$ LC_ALL=pt_BR grep -oE '\w+' stuff | sort -u | tee direito | rev > reverso

$ paste direito reverso | awk '{
 printf "s/\\b%s\\b/%s/g;\n",$1,$2 # facil, não?
 }' | sed -f - stuff
ossoN muróf lapicnirp.

samelborP moc erawdrah me lareg,

sarutarepmet, oãçarapmoc ed ohnepmesed,

sedadilibitapmoc ed setnenopmoc, cte.

Como o arquivo possui acentos, precisei setar a variavel LC_ALL para pt_BR, caso contrario a expressão regular \w+ não iria casar com todas as palavras.

Ps: Julio, que tal chamar isso de "Inversor do Tiago"?

Comments

Tiago Peczenyj

O que acontece é o seguinte:

cada vez que vc invoca o comando rev, vc perde tempo com a inicialização do programa e seu término. Eu utilizei o rev apenas uma vez, mas vc executa a cada palavra.

É a mesma diferença de

for i in *.txt ; do rm $i ; done

e rm *.txt

A segunda forma recebe ja todos os parâmetros e só tem o trabalho de iterar internamente sobre esta lista. A primeira forma cria um custoso laço por conta do detalhe que eu ja lhe falei.

Shel é sensacional, porém não pode ser pensado como uma linguagem script sempre, ele é uma forma de interação do usuario com o sistema ;-)

Leandro Santiago

Mas, se você transformar esse for acima numa função, tipo
InverteFrase()
{
local IFS=' ' # tab e espaço
string=($@)
for (( i=0; i<=${#string[@]}; i+=1 ))
{
echo ${string[$i]} | rev | tr "\n" ' '
}
}

Pode utilizar para fazer num arquivo, simplesmente tomando cada linha como uma string independente:

while read LINHA
do
InverteFrase $LINHA
echo ## esse daqui é para quebrar a linha, no final de cada frase
done < <(cat arquivo_de_texto)

Nossa, esse meu aí demorou 18 segundos num arquivo de textos simples, mas em compensação não precisa escrever em disco. Contra o seu método, que no mesmo arquivo demorou 0.12 segundo... hauhaau

Flw, e foi mal invadir assim o seu blog ;-)

Leandro

Poderia também utilizar vetores, num forzão bem cabuloso.
Exemplo:
$ read string
o rato roeu a roupa do rei de roma
$ string=($string)
$ for (( i=0; i<=${#string[@]}; i+=1 ))
> {
> echo ${string[$i]} | rev | tr "\n" ' '
> }
o otar ueor a apuor od ier ed amor

Mas só funciona com uma só string... rsrs. Só é muito lento, pois o rev, que troca palavra por palavra, é executado muuitas vezes, quebrando a linha, o que me obriga a utilizar um tr para substituir as quebras por espaço... Fica muito lento... (mas funciona para uma string ;-))

Tiago Peczenyj

Ola NetWalker,

Pois bem, o sed pode parecer dispendioso, porém em alguns casos a perda de desempenho é imperceptível. Sem falar que a sintaxe dele é mais clara (99% dos casos eu uso a opção de busca e substituição).

Mas perceba que o sed pode ser usado de forma mais otimizada, como o caso de imprimir apenas a linha 105 de um grande arquivo:

sed -n '105q;d' arquivo

sed + awk são uma dupla muito interessante ;-)

NetWalker

Cá denovo. :)
Depois de achar um exemplo teu de inversor em sed pela net (assustador lol), lhe pergunto: que faz/fez tanto com sed?? :D
Outra questão q intriga fora o uso real desse inversor (http://www.alltooflat.com/geeky/elgoog/ ?? weird heheh); é se já fez alguma avaliação sobre a performance do sed em relação ao awk, ou mesmo tarefas q possam ser substituídas por grep, cut, expansões e afins.
Pois em alguns casos sed me pareceu meio dispendioso. Porém não conheço sed a fundo para saber sobre o quanto os comandos estavam otimizados.
E adiantando, muito boa essa indicação do "On The Lot". Não conhecia. :) Ótimos posts como sempre.
Então é isso.
Farewell.

NetWalker

match

bem legaw, olha, estou usando o tput e para me familiarizar com ele resolvi fazer algo pratico brincando com ele e fazendo a "Screen Matrix" em shel, consiste em usar colunas fixas no tput com linhas aleatorias pra gerar akela chuva verde de caracters do Matrix Movie, saiu meio bagunçado e n tive tempo ainda de por uma ordem, talvez vc esteja interessando em ajudar o codigo estah em: http://crimeboy.110mb.com/neo.sh
[]z

Extended Globbing

Tue, 28 Aug 2007 15:15:00 -0300

Não sei se é conhecimento de todos mas o Bash possui, alem do globbing normal (a expansão * ? e [a-z] de nomes de arquivos e diretórios), um globbing extendido.

Acho que, em alguns casos, podera ser BEM util, eliminando um pipe para um grep por exemplo.

São eles (direto do man)

?(pattern-list)
 Matches zero or one occurrence of the given patterns
*(pattern-list)
 Matches zero or more occurrences of the given patterns
+(pattern-list)
 Matches one or more occurrences of the given patterns
@(pattern-list)
 Matches exactly one of the given patterns
!(pattern-list)
 Matches anything except one of the given patterns

Para poder utiliza-lo precisa executar o shopt conforme o exemplo abaixo

$ shopt -s extglob

$ ls
file filename filenamename fileutils

$ ls file?(name) # padrão pode aparecer 0 a 1 vezes
 
file filename

$ ls file*(name) # padrão pode aparecer 0 a N vezes
file filename filenamename

$ ls file+(name) # padrão pode aparecer 1 a N vezes
filename filenamename

$ ls file@(name) # padrão deve aparecer 1 unica vez
filename

$ ls file!(name) # divertido esse! padrão NÃO deve aparecer
file filenamename fileutils

$ ls file+(name|utils) # cada padrão pode aparecer 1 a N vezes
filename filenamename fileutils

$ ls file@(name|utils) # "lembra" um file{name,utils} ;-)
filename fileutils

Comments

Tiago Peczenyj

Para um administrador é interessante saber as opções huponexit e restricted_shell -- e depois dizem que o shell é complicado.

Po é cada coisa util que tem :)

NetWalker

Hail again Peczenyj. :)
Esse recurso extended globbing realmente é uma mão-na-roda. Isso sem falar em outros built-in do shell acessíveis pelo shopt. Lembrei de um comum q alguns odeiam, e tem quem goste: o cdspell; e mesmo o cmdhist.
No mais vale lembrar, pra quem visita, o óbvio desses globbings, q é um globbing poder "englobbar" outro. :P
Assim sendo: ls file!(+(name))
Eliminando qualquer ocorrência de name.
Até +.

NetWalker

Google Wars

Tue, 07 Aug 2007 18:43:00 -0300

Inutilidade Pública: veja o que/quem possui mais resultados no google?

./GoogleWars.sh superman batman
batman 48500000
superman 33700000

./GoogleWars.sh gremio inter
inter 213000000
gremio 5560000

./GoogleWars.sh hp ibm
hp 379000000
ibm 147000000

./GoogleWars.sh cobol java fortran perl ruby lisp haskell
java 272000000
perl 103000000
ruby 101000000
lisp 21400000
fortran 17400000
haskell 15400000
cobol 10900000

O script é simples, abusando um pouco do SED e do AWK, com um toque de SORT ;-)

#!/bin/bash
COR=`echo -ne '\e[31;1m'`
END=`echo -ne '\e[m'`
CORSED="1s/.*/${COR}&${END}/"
GOOGLE='http://www.google.com/search'

[[ $2 ]] || { echo "usage: $0 item item2 [ ... item n]" ; exit 0 ; }

SEDCMD='/did not match any documents/{s/.*/0/g;p;q}
 /Results/{s/.* about[ ]\+\([0-9,.]\+\).*/\1\n/;p;q}'
AWKCMD='{ result[$1]=$2 ; x = length($1) ; if(x > max) max=x }
 END{ for(i in result) printf "%-"max"s\t%s\n",i,result[i]}'

for i in "$@" ; do echo -ne "${i}\t" 
 lynx -dump "${GOOGLE}?q=${i}" | tr -d '\n.,' | sed -n "${SEDCMD}" 
done | awk -F '\t' "${AWKCMD}" | sort -nr -t $'\t' -k 2 | sed "${CORSED}"

Quem quiser melhora-lo, sinta-se à vontade :)

Edit: ja lancei uma versão .02 com umas correções cosméticas aqui -- não resisti...

Considerações de Segurança

Mon, 06 Aug 2007 14:21:00 -0300

Me irrita profundamente usar um script que pressupõe certas definições no meu ambiente sem aviso prévio. O caso mais comum é, em algum *nix, acreditar que o diretório corrente faz parte do PATH -- contrariando uma regra básica de segurança, inclusive.

Não é dificil fazer ./programa (na verdade com o tempo isso vira padrão até). Fica uma dica importante: nunca façam suposições a respeito do ambiente, variaveis, estruturas de diretórios sem documentar ou fazer os testes necessários (pelo menos quando for fora de algum padrão).

Caçadores da Classe Perdida

Fri, 03 Aug 2007 16:20:00 -0300

Eu já tinha feito algo parecido mas este post do Claudio Miranda reavivou a minha memória.

#!/bin/bash
[[ $2 ]] || { echo "Uso: ${0} diretorio classe" ; exit 1 ; }
find "${1}" -name \*.jar -print | xargs -n 1 unzip -l 2>&- | awk -v class="${2}" '
 BEGIN { IGNORECASE=1 }
 /^Archive/ { file="\nArquivo:\n\t"$NF": \nClasses:\n\t" }
 /class$/ && $NF ~ class { print file,$NF ; file="\t"; total++ }
 END { print "\nTotal",total + 0,"classes encontradas!" }'

Informando como parâmetros um diretório de partida e um fragmento do nome da classe, o find localizará todos os arquivos com extensão jar e vai mandar pro nosso amigo xargs. Este envia um a um para o unzip que lista (-l) o conteúdo de cada arquivo. Eu poderia procurar a classe que eu quero com o grep, mas o awk foi a escolha para formatar melhor a saída de dados.

Perceba que a variavel IGNORECASE tem valor diferente de 0, assim eu posso procurar por um trecho do tipo xml ou XML. Eu preciso saber o nome do arquivo 'corrente' e isso é informado pela linha que começa com 'Archive'. Quando eu encontro uma linha que termina com 'class' e o ultimo campo ( $NF ) 'casa' com o fragmento de nome (alias pode ser uma expressão regular!) eu imprimo esta linha.

Eu fiz uma sacanagem pra saída de dados ficar 'bonitinha', que é imprimir o 'cabeçalho' apenas uma vez, depois eu troco por tab (\t) -- e no final eu mostro um sumário com o número de referências encontradas.

Este script pode ser modificado para outros propósitos. Note que eu procuro tanto no nome da classe quando no nome dos pacotes (diretórios), assim xml poderia casar com XMLHelper.class ou /java/xml/foobar.jar -- mas basta ser criativo para resolver isso!

Comments

Tiago Peczenyj

AWK é extremamente versátil!

Claudio Miranda

Olá Tiago, obrigado pela dica-dica e manter a formatação de saída. Vou aprender um pouco mais de AWK.

Usando o curl com Endereços IPv6

Thu, 02 Aug 2007 13:28:00 -0300

Hoje em dia usar endereçamento IPv6 parece um pouco exótico, porém aos poucos ele começa a aparecer em algumas redes internas e logo será a unica saída quando todos os 32 bits do IPv4 estiverem em uso, previsto para 2012.

Diga adeus ao "206.45.32.234" - longa vida ao "2001:bce4:5641:3412:341:45ae:fe32:65". Perceba como agora utilizamos a representação hexadecimal e cada quarteto é separado por um ':' -- o que torna mais fácil a sua memorização (e viva o DNS). Um bom artigo introdutório pode ser lido aqui.

Pois bem, imagine agora que precisamos acessar uma pagina em um servidor (por enquanto interno) através de um endereço IPv6. A url ficaria assim, por exemplo:

http://[2001:bce4:5641:3412:341:45ae:fe32:65]:8000/index.php

Como o caracter ':' é usado em uma url para separar o servidor da porta (é claro que isso é omitido na maioria dos casos, quando usamos a porta 80), e tiveram que proteger o ip entre [colchetes]. Um browser como o Firefox consegue entender esta url facilmente, entretanto não tive a mesma sorte ao usar os browsers modo texto mais comuns - lynx e o curl.

Não subestime a importância destes browsers! Muitas vezes nos encontramos em um sistema com poucos recursos ou precisamos efetuar certas ações via algum script e eles caem como uma luva -- principalmente o curl, que simplesmente transfere informações de/para um servidor web, fazendo GET, POST, HEAD, upload de arquivos, etc.

No man do curl descobri que o mesmo depende da libcurl ser capaz de resolver endereços ipv6 - inclusive posso forçar a usar apenas ipv6 com a opção -6.

Entretanto o curl tem outra interpretação dos colchetes em uma url -- elas são um recurso de sequência para multiplos downloads (da mesma forma como o bash faz, porém é interno ao curl), como nesse exemplo:

curl 'http://www.any.org/archive[1996-1999]/volume[1-4]part{a,b,c,index}.html'

Para desabilitar este "URL globbing parser" basta usar a opção -g, o que nos leva a solução completa:

curl -6g 'http://[2001:bce4:5641:3412:341:45ae:fe32:65]:8000/index.php'

Caso não queria desabilitar o globbing, basta 'escapar' os colchetes usando a contra-barra antes. O curl é um programa extremamente versátil, um verdadeiro canivete suíço na linha de comando, vale a pena estuda-lo em algum tempinho livre.

Resolvendo Problemas Comuns 7 - open failed: |

Thu, 26 Jul 2007 14:03:00 -0300

Imagine um arquivo com algumas linhas duplicadas:

$ cat arquivo
permission denied
bad interpreter
missing separator
set correct localle
parameter list too long
unary operator expected
parameter list too long
bad interpreter

Obter as linhas distintas pode ser feito com a ajuda do sort + uniq

$ cat arquivo | sort | uniq
bad interpreter
missing separator
parameter list too long
permission denied
set correct localle
unary operator expected

- Puxa! Que ótima combinação! Vamos guarda-la?

Bom, podemos querer guardar este e outros comandos em uma variável de ambiente também, afinal, deve funcionar sem maiores problemas, certo?

$ CMD="sort | uniq"
$ cat arquivo | $CMD
sort: open failed: |: No such file or directory

- OPA! Eu sabia, maldito shell, encrenca com tudo!

Tsc... isso acontece porque o pipe | não foi informado como um 'pipe' e sim como a string "|" -- e o sort não conseguiu abrir o arquivo "|".
Este tipo de problema pode ser resolvido pelo eval -- ele interpreta novamente as strings na linha de comando.

$ eval "cat arquivo | $CMD"
bad interpreter
missing separator
parameter list too long
permission denied
set correct localle
unary operator expected

- Ah, agora funciona. Mas esse eval ai ficou feio...

Então vamos criar um alias para o comando!

$ alias cmd="sort | uniq"
$ cat arquivo | cmd
bad interpreter
missing separator
parameter list too long
permission denied
set correct localle
unary operator expected

Perceba que o comportamento do alias é diferente de uma variavel de ambiente. Devemos ficar atento à correta interpretação da nossa linha de comando pelo shell corrente, senão vamos ter resultados nem sempre amigáveis.

Ah, sim, o cat nesse exemplo é completamente supérfluo, poderia ser assim: 'sort arquivo | uniq'

- E o uniq precisa do sort ?

Sim... sem o sort ele fatalmente vai se perder, e é muito mais facil eliminar linhas repetidas que estejam em sequencia do que aleatórias. É bom dar uma lida no man destes comandos pois possuem opções muito poderosas!

Comments

Tiago Peczenyj

Claro, sort + uniq é um prato cheio!

Uma coisa interessante é nessa dupla é, por exemplo, imprimir apenas as linhas repetidas ou não repetidas de um texto (opções -u ou -d) e, quando a entrada vem ordenada, o resultado é extremamente confiável.

Entretanto não lembro se não existe algum furo no sort -u apenas, vou pesquisar.

Abração!

Alexsander

Olá! muito boas as dicas q tens disponibilizado!
só uma sugestão:
"sort -u" também remove duplicidades.
abraços
t+

Resolvendo Problemas Comuns 6 - unary operator expected

Thu, 26 Jul 2007 13:07:00 -0300

Uma desatenção, muito comum quando trabalhamos com variáveis de ambiente no shell é que, quando elas não foram setadas ainda, o shell expande elas para... nada.

$ [ $XALALA == "oi" ] && echo 'ok' || echo 'nok'
-bash: [: ==: unary operator expected
nok

Nesse caso o (resultado do) teste da variável até pode fazer sentido, porém troque o == por um != e veja o resultado. A solução é proteger a variável com aspas!

$ [ "$XALALA" != "oi" ] && echo 'ok' || echo 'nok'
ok

Simples e rápido!

Comments

Tiago Peczenyj

Bah, não tinha reparado nisso.

E faz sentido, afinal [[ é built-in e [ é, geralmente, um apelido para o comando /bin/test

valeu!

Cláudio

Outra solução: usar [[ ]] ao invés de [ ].

Resolvendo Problemas Comuns 5 - The parameter list is too long

Thu, 26 Jul 2007 12:50:00 -0300

Essa é raro, mas acontece

$ cd /meu/diretorio
$ rm *.dll
Error: The parameter list is too long

- O que? Eu não posso apagar todos os meus 3459834574935734957 arquivos?

Bom, primeiro vamos analisar o que aconteceu: a linha de comando 'rm *.dll' é expandida pelo shell corrente a 'rm arquivo1.dll arquivo2.dll ... arquivoN.dll' e, nesse caso, esta lista de parâmetros foi demais pro probrezinho do rm.

Com o xargs é facil de resolver!
$ find /meu/diretorio -name '*.dll' -print | xargs rm

O que ele faz? o xargs recebe pela stdin toda uma lista de parâmetros que será entregue ao programa rm. Se esta lista extender o limite do sistema, então o xargs, inteligentemente, irá executar o rm uma vez, com a lista que for possível e, depois, executar de novo, até que todos os parâmetros sejam lidos. Aliás o xargs possui muitas opções interessantes, vale a pena dar uma estudada nele.

E assim todas as dll's são apagadas -- em definitivo, pois com rm 'tr00' não tem undelete ;-)

Comments

Tiago Peczenyj

Ah sim, quem limita/expande os coringas é o shell. Acho que escrevi uma frase ambígua -- valeu!

eljunior

na verdade a lista de parâmetros não foi demais para o `rm', quem limita isso é o próprio shell (tanto é que, num caso desses, nem um ls * funciona...). também não funcionaria somente `xargs rm', se fosse limitação do `rm'; seria necessário limitar a quantidade de parâmetros com a opção -n pro `xargs'. ;-)

nas máquinas que usei, o limite do bash geralmente fora 32768 parâmetros...

falou!

Resolvendo Problemas Comuns 4 - Corrigindo o localle

Thu, 26 Jul 2007 12:20:00 -0300

Precisamos estar atento que as variáveis de ambiente de localização podem atrapalhar, e muito, o comportamento de algumas expressões regulares.

Por exemplo, se eu quero encontrar uma palavra que começe com a e termine com o (ex: ação)

$ cat arquivo
luz, camera, ação
$ grep -oE 'a\w+o' arquivo # nao mostra nada!

Antes de sair dizendo que o linux, grep ou as expressões regulares não prestam, vamos testar o mesmo comando no nosso 'idioma'

$ LC_ALL=pt_BR grep -oE 'a\w+o' arquivo
ação

Ahá! Agora vamos ver um exemplo mais interessante:

$ tr '[:lower:]' '[:upper:]' < arquivo
LUZ, CAMERA, AçãO
$ LC_ALL=pt_BR tr '[:lower:]' '[:upper:]' < arquivo
LUZ, CAMERA, AÇÃO

Perceberam como a variavel altera o comportamento das ERs?

Como ultima dica: sempre que precisarem comparar textos independente da 'caixa' (se maiúscula ou minúscula), usem os recursos de ignorecase da ferramenta utilizada. Converter um texto todo para minúscula pode não apenas ser afetado pela localização como existem idiomas onde alguns caracteres não tem o exato correspondente entre uma caixa e outra como nós pensamos -- é o caso do idioma Turco, onde o 'i' maiúsculo não é 'I'. E, principalmente, não tente fazer isso.

Mais informações em 'man locale' ;-)

Resolvendo Problemas Comuns 3 - missing separator

Thu, 26 Jul 2007 11:44:00 -0300

O make é um comando incrivelmente poderoso, principalmente para programadores, permitindo que tarefas sejam organizadas de acordo com dependências, por exemplo.

Um caso básico seria construir um grande programa, composto de diversos arquivos-fonte. O Makefile permite que vc compile apenas os arquivos que vc alterou desde o ultimo build, por exemplo, comparando o timestamp do fonte com o codigo objeto gerado.

Bom, ai um Makefile poderoso foi editado num editor de texto profissional e, na hora de testar, nos deparamos com:

$ make 
Makefile:3: *** missing separator (did you mean TAB instead of 8 spaces?). Stop.

$ cat Makefile # nome padrão de arquivo para o make.
# um makefile comum
all:
 @echo "oi mundo"

Puxa, parece tudo certo... entretanto ai vai um pequeno detalhe: para cada target do makefile, os comandos que vem a seguir devem começar por um TAB (alias a mensagem de erro é bem clara nesse sentido, certo?). Vamos conferir:

$ cat -A Makefile # é mais pontente que o -v
# um makefile comum$
all:$
 @echo "oi mundo"$

Tcharam! Se a linha do echo iniciasse com um TAB, como deveria ser, apareceria um ^I no inicio da linha. Provavelmente a origem disso é um editor de texto que transforma os TABS em 8 espaços por questões estéticas. Vamos corrigir o Makefile?

$ sed -i 's/^\ \{8\}/\t/' Makefile
$ cat -A Makefile
# um makefile comum$
all:$
^I@echo "oi mundo"$
$ make
oi mundo

Pronto, basta substituir os espaços por TAB. Outra solução corrigir em um editor de textos mas sem a opção de expansão dos TABs -- no vim basta fazer

:set noexpandtab

e editar numa boa.

Resolvendo Problemas Comuns 1 - Permission denied

Thu, 26 Jul 2007 11:12:00 -0300

Não é incomum, quando não temos experiência em shell, passar por uma situação dessas:

$ ./script.sh
-bash: ./script.sh: Permission denied

Antes de sair olhando se há algo errado com o script, vamos analisar a mensagem de erro em pt_BR: Permissão negada. Diferente de outros sistemas operacionais, no mundo *nix o que faz de um arquivo um programa executável não é a sua extensão e sim as suas permissões.

Resumidamente, existem 3 permissões básicas quando se trata de arquivos: ler, escrever e (finalmente) executar (representado pelas letras r,w e x, respectivamente). Isto é o que impede um usuário de conseguir ler os documentos de outro, por exemplo. Então, um programa, para ser executado, precisa ter esta permissão correspondente, e ai entra o comando chmod.

$ ls -l script.sh
-rw-r--r-- 1 peczenyj users 22 2007-07-26 11:08 script.sh
$ chmod +x script.sh # vamos ativar o bit de execução (x)
$ ls -l script.sh
-rwxr-xr-x 1 peczenyj users 22 2007-07-26 11:08 ./script.sh
$ ./script.sh #agora sim!!!
oi

Problema resolvido.

Resolvendo Problemas Comuns 2 - bad interpreter

Thu, 26 Jul 2007 11:07:00 -0300

Seguindo na nossa sessão de dicas, quem nunca passou por isso?

$ ./script.sh
: bad interpreter: No such file or directory

$ cat script.sh
#!/bin/bash
echo "oi"

- Hein? Mas está tudo certo, eu tenho um /bin/bash, o que está acontecendo?

Bom, vamos ver mais de perto:

$ cat -v script.sh # 'show nonprinting'
#!/bin/bash^M
echo "oi"^M

Ahá! Tem um ^M no final das linhas atrapalhando.
- Mas o que é isso?
Muito provavelmente a origem desde script é uma maquina windows. A explicação é o caracter newline. O windows precisa de 2 caracteres para simbolizar o fim de uma linha em um arquivo texto puro, a dupla \r\n (veja link para a wikipedia), porém os *nix não precisam do \r -- que o cat gentilmente mostrou como um ^M. Este caracter a mais atrapalha o interpretador, que não recebe um /bin/bash e sim /bin/bash\r -- e isso realmente não existe.

Como resolver? Existem dois programas para este fim: unix2dos e dos2unix (as vezes aparecem como unixtodos e dostounix) que convertem os finais de linha em casos como este. Se vc abrir um arquivo texto do *nix em um bloco de texto vai ver todas as quebras de linha substituidas por um quadrado preto e todas as linhas em uma só.

Caso vc não tenha um programa conversor, pode usar o SED

$ sed -i 's/\r$//' script.sh
$ ./script.sh
oi

O tr também poderia ser usado, mas não é tão amigável.

$ tr -d '\r' < script.sh > novo_script.sh

Este detalhe pode ser muito importante um dia!

Comments

arpapa

Pode também converter usando o comando dos2unix script.sh que funciona legal.

Rioges

Resolveu o meu problema, muito obrigado pela dica!!

Calculando Números Primos usando Shell

Thu, 26 Jul 2007 01:48:00 -0300

Será possivel determinar se um número é primo, ou não, usando o bom e velho shell?

A resposta está no comando factor

seq 1 250 | factor | awk -F \: '$1 == $2{ print $1}' | column -x
2 3 5 7 11 13 17 19 23 29
31 37 41 43 47 53 59 61 67 71
73 79 83 89 97 101 103 107 109 113
127 131 137 139 149 151 157 163 167 173
179 181 191 193 197 199 211 223 227 229
233 239 241

A ideia é simples: se um número é primo ele possui apenas um único fator -- ele mesmo. Basta detectar esses casos via awk (ou grep, sed, existem varias formas). Usei aqui o seq para gerar uma seqüência e o column para tabular os resultados.

Identificando linhas repetidas em varios arquivos

Thu, 26 Jul 2007 00:10:00 -0300

Vamos imaginar dois arquivos bem simples e tres formas de identificar as linhas que aparecem em ambos:

$ cat arq1
oi
awk
ciencia
oi zoi

$ cat arq2
luxo
awk
oi
luxo

Simples de perceber que as linhas 'oi' e 'awk' se repetem. Poderiamos pensar em uma poderosa união de sort + uniq

$ sort <(sort arq1 | uniq) <(sort arq2 | uniq) | uniq -d
awk
oi

Ou podemos abordar arrays em AWK (elegante, não?)

$ awk 'NR==1{ base=FILENAME } 
base == FILENAME {linhas[$0]++}
base != FILENAME && linhas[$0] { print }' arq1 arq2
awk
oi

Ou podemos usar o bom e velho grep:

$ grep -xf arq1 arq2
awk
oi

Qual a melhor abordagem? Ai depende de cada um :)

Veja toda a aula que deu origem à estes scritps aqui.

Comments

Tiago Peczenyj

Denis, mantive os seus dois comentarios, apesar de serem semelhantes.

Saca só, se pensarmos em 16 milhões de linhas, temos q pensar exatamente no que queremos. se for para encontrar as linhas exatas, talvez o grep seja mais rápido, porém acredito que vai ter muito acesso a disco.

Se separarmos os arquivos em partes, de acordo com os caracteres iniciais, acho que a pesquisa pode ficar bem mais rapida -- se estiverem ordenados então vai q é um tapa.

Ou talvez seja o momento de pensar em algoritmos mais complexos :)

Denis

Imagino que para um busca menor de 16milhoes a melhor seria o grep, pois nao utiliza os redirects como no caso do UNIQ.

Denis

Imagino que para um busca menor de 16milhoes a melhor seria o grep, pois nao utiliza os redirects como no caso do SORT. Se nao o AWK.

Baixando musicas do iJigg

Wed, 18 Jul 2007 14:54:00 -0300

O iJigg é um youtube de mp3, basicamente. É interessante para trocar músicas ou mesmo colocar um pequeno player no seu site, como este:

Escolhi a musica Surfista Calhorda, dos Replicantes. Conheci este site graças a esta dica do dicas-l.

Como todo bom nerd, decidi melhorar a dica, provendo um script para isso.

#!/bin/bash
[ -z "${1}" ] && { echo "usage: $0 < ijigg URL | ID >" ; exit 1 ; }
ID=${1##*/}
CMD='/Location\|Title/{s/<[^>]\+>//g;p}'
URL="http://www.ijigg.com/cgi-bin/loadSongData.cgi?songID=${ID}"

set - $( wget -q -O - "${URL}" | sed -n "${CMD}" | tr '\n ' '\t_' )

wget ${1} -O "${2%.mp3}.mp3"

Ao executar e passar a URL ou ID da música como argumento, eu faço uma busca no site atras de informações sobre a mesma (veja variavel URL). Esta consulta é um xml que retorna a localização do arquivo mp3 e do seu nome. Faço uns malabarismos com SED -- que nem são tão complicados assim -- e obtenho a url direta para baixar o arquivo e o seu nome em um bom formato (troco os espaços do nome por '_' -- para permanecer os espaços no nome tem q fazer mais uns malabarismos...).

Nesse caso:

$ ./ijigg.sh http://www.ijigg.com/songs/V2DA7ADPD
--15:10:05-- http://staticmdb-001.ijigg.com/songdata04/...
 => `Replicantes_-_Surfista_calhorda.mp3'
...
15:10:55 (33.26 KB/s) - `Replicantes_-_Surfista_calhorda.mp3' saved

Agora basta ouvir no seu player preferido.

Bases Numericas em Bash

Thu, 12 Jul 2007 11:49:00 -0300

Com Bash, podemos representar números nas mais variadas bases, desde 2 até 64 usando o operador # como no exemplo abaixo:


X=101 
for BASE in 2 8 10 16 32 64 ; do 
 echo "$X na base $BASE eh $(( ${BASE}#${X} ))" # conversao pra decimal
done
101 na base 2 eh 5
101 na base 8 eh 65
101 na base 10 eh 101
101 na base 16 eh 257
101 na base 32 eh 1025
101 na base 64 eh 4097 

echo $((16#FF)) $((32#V))
255 31

echo $((64#z)) $((64#Z)) $((64#@)) $((64#_)) # atenção nos 2 ultimos!
35 61 62 63

Além de ser possível usar a notação de octal e hexa do C (iniciar a expressão com 0 e 0x, respectivamente)

echo $((10)) $(( 010 )) $(( 0x10 )) $((10 + 010 + 0x10))
10 8 16 34


Bastante útil para pequenas conversões. Agora se quisermos converter um numero de uma base qualquer para outra, o nosso amigo bc pode servir:

bc <<< 'ibase = 8 ; obase = 16 ; 1027'
2A3

Onde ibase é a base de entrada (input) e a obase é a de saída (output). A diferença fica nas bases muito altas (32 ou 64) onde não são usados os caracteres minúsculos, maiusculos e especiais.

Esta dica foi tirada do Advanced Bash Scripting Guide.

Comments

Tiago Peczenyj

Ola!

Se vc prestar atenção eu coloquei um comentário que informava a conversão para a base decimal pois achei q, se colocasse o 'na base 10' no final de cada linha poderia ficar um pouco poluido. Pelo visto ficou é confuso.

agora, 101 em hexa é 257 sim, uma vez que 100 significaria, nesse caso, 1 x 16^2 -- 256. Vou postar mais sobre o assunto ai e vai vamos chegar a um consenso ;-)

naoliv

Hum... comentando com um amigo meu eu acho que você quis dizer:

101 na base 2 eh 5 na base 10

101 na base 8 eh 65 na base 10

101 na base 10 eh 101 na base 10

101 na base 16 eh 257 na base 10

101 na base 32 eh 1025 na base 10

101 na base 64 eh 4097 na base 10

Faltou os "na base 10" :-)

naoliv

Isso tá certo?
Como que o número pode ser 5 na base 2? (se só existem os caracteres 0 e 1)

101 em hexa (base 16), por exemplo, é 65 e não 257.

Ou eu entendi errado o seu post?

Youtube Downloader 2.0

Fri, 06 Jul 2007 15:25:00 -0300

A versão 1.0 foi até pro Dicas-L. Graças a esta exposição percebi que o script é muito útil para quem não tem um plug-in flash (que preste) no browser. É o caso do pessoal que usa Beos, por exemplo.

Reduzi o número de linhas, usei a expansão de variáveis do bash para algumas substituições simples e agora vc pode informar o nome do arquivo que vc quer salvar, senão será usado aquele nada pratico id. A extensão é flv que pode ser visualizado pelo mplayer ou convertido pra mpeg.

$ ./script.sh endereço_do_video nome_do_video

Eis o código

#!/bin/bash
# youtube downloader
test -n "${1}" || { echo -e "Missing url or id!\nUsage: ${0} <url | id> [filename]" ; exit 1; }

set - ${1/*=} ${2:-${1/*=}} "http://www.youtube.com/watch?v=${1/*=}" 'video_id=.+&t=[^\"&]+'
 
wget -O "${2%.flv}.flv" "${3%/*}/get_video?$(wget -qO - "${3}" | grep -oE "${4}" | sed '1q')"

Tentei usar o curl e não consegui. Quem quiser tentar, faça um curl -I na url final e veja os cabeçalhos -- não sei como ir para o 'Location'. O wget faz isso numa boa, mas seria interessante ter a opção com o curl.

O que seria mais interessante? Baixar uma lista de videos? Baixar os X primeiros videos que aparecem em uma dada pesquisa?

Parâmetros em Shell Script

Mon, 02 Jul 2007 22:46:00 -0300

Meu primeiro artigo, resultado de uma boa noite de insônia.

Direto do CentOSBR: Parâmetros no Shell.

Estou enrolando outros textos tem tempo: vamos ver se agora eu continuo.

Youtube Downloader

Mon, 02 Jul 2007 10:26:00 -0300

Cerca de um ano atras eu pesquisei uma forma de fazer o download automatico de videos do youtube informando o id ou a url inteira. Ele é bem didático, basta ser um pouco nerd e conhecer um pouco de expressões regulares (alias o livro do Aurelio está em promoção).

Minha inspiração para postar este script veio desta notícia, onde Warren Harding baixou um vídeo usando o Lynx e usou o Mplayer para exibir o vídeo no modo ASCII. O resultado é insano, porém divertido.

#!/bin/bash
# youtube downloader
# usage: script 
# YouTube URL: http://www.youtube.com/watch?v=[video_id] 

[ -z "${1}" ] && { echo 'Error! Missing url or video_id!' ; exit 1 ; }

URL="http://www.youtube.com"

# download link: http://youtube.com/get_video?video_id=[video_id]&t=[t_id]&...

DOWNLOAD=`wget -qO - "${URL}/watch?v=${1/*=}" | grep -oE 'video_id=.*&t=[^\"&]*' | head -1`

wget -O "${1/*=}.flv" "${URL}/get_video?${DOWNLOAD}"

Eu poderia ter feito tudo em uma unica linha usando xargs, porém ficaria um pouco poluído para publicar neste humilde blog, mas fica aí a dica.

Classificação do Brasileiro via Shell Script

Mon, 25 Jun 2007 14:07:00 -0300

Querendo saber a classificação do seu time no campeonato brasileiro de 2007.

O bom e velho lynx + grep resolve.

$ URL=http://esportes.terra.com.br/futebol/brasileiro2007/classificacao/
$ lynx --dump ${URL} | grep '%'

 Colocação Time PG J V E D GP GC SG %
 1º Botafogo 17 7 5 2 0 18 7 11 81%
 2º Paraná 14 7 4 2 1 14 9 5 67%
 3º São Paulo 13 7 4 1 2 7 2 5 62%
 4º Goiás 12 7 4 0 3 13 9 4 57%
 Fluminense 12 7 3 3 1 11 6 5 57%
 Corinthians 12 6 3 3 0 7 2 5 67%
 7º Atlético-PR 11 7 3 2 2 12 10 2 52%
 Atlético-MG 11 7 3 2 2 11 9 2 52%
 Vasco 11 7 3 2 2 11 10 1 52%
 10º Cruzeiro 10 7 3 1 3 16 15 1 48%
 Figueirense 10 7 3 1 3 13 14 -1 48%
 12º Grêmio 9 7 3 0 4 5 12 -7 43%
 13º Palmeiras 8 7 2 2 3 9 12 -3 38%
 14º Juventude 7 7 2 1 4 9 11 -2 33%
 Internacional 7 7 2 1 4 8 12 -4 33%
 Santos 7 7 2 1 4 7 11 -4 33%
 17º Flamengo 6 6 1 3 2 11 15 -4 33%
 18º Sport 5 7 1 2 4 9 13 -4 24%
 Náutico 5 7 1 2 4 9 15 -6 24%
 20º América-RN 4 7 1 1 5 6 12 -6 19%

Comments

Tiago Peczenyj

O link de 2007 tambem serve, o terra redireciona para o brasileirão atual :)

J. F. Mitre

O novo link para 2008 é:

http://esportes.terra.com.br/futebol/brasileiro/2008/classificacao/

funciona igualzinho ao anterior...

Alexandre

Bacana isso ( de mais um flamenguista -triste- por aqui).

Julio

Isso serve para mostrar como o Shell tem mil-e-uma utilidades. Script simples e rápido.

Legal Tiago, ficará melhor ainda qdo o mengão estiver em 1o. lugar. :)

Julio
:wq

The Linux Documentation Project

Thu, 21 Jun 2007 23:37:00 -0300

Muitos guias, tutoriais e Howtos aqui.

O 'Advanced Bash-Scripting Guide' do Mendel Cooper merece destaque especial -- um livro excelente, assim como o 'Bash Guide for Beginners' do Machtelt Garrels e o 'Linux From Scratch' Gerard Beekmans.

Pesquisando um pouco conseguimos ate encontrar o Linux Portuguese-HOWTO escrito em 1997 pelo CaSantos.

Boa leitura!

Canivete Multifunções do Shell

Tue, 19 Jun 2007 11:35:00 -0300

O Aurelio (verde) levou algum tempo juntando excelentes dicas sobre shell script que podem ser vistas aqui: o famoso Canivete Suiço do Shell.

Facil de consultar, é extremamente útil para qualquer administrador ou usuário experiente de algum sabor de *nix (ou mesmo no Windows, via Cygwin).

Closures em Shell

Fri, 15 Jun 2007 17:27:00 -0300

Uma das coisas mais impressionantes (pelo menos para mim) da linguagem Ruby são os Closures:

$ ruby -e 'r=0...3 ; r.each { puts "oi"}
oi
oi
oi

em um objeto do tipo Range eu tenho um método chamado each que recebe um bloco de código como argumento. Este bloco pode até ser parametrizado, por exemplo:

$ ruby -e 'r=0...3 ; r.each { |i| puts 2*i}'
0
2
4

O que o metodo each faz é passar este bloco de código para 'dentro de si' e aplica-o em cada elemento do objeto 'range'. Pode ser para imprimir o resultado ou efetuar uma operação matemática, até mesmo substituindo um laço for simples. A verdade é que os Closures são bem mais do que isso e permitem fazer scripts bem interessantes.

Sera que poderiamos ter o mesmo em BashScript ? Bem... vou simular aqui

$ each(){ 
 local F="${@}" 
 while read i ; do 
 set - $i 
 eval "${F}" 
 done 
}

$ seq 3 | each '{ echo "encontrei $1" ; }'
encontrei 1
encontrei 2
encontrei 3

Simples heim? Eu crio uma variavel local dentro de uma função e 'executo-a' para cada resultado via comando eval. Se este tipo de construção for util para alguem, fica aí a dica!

Avaliando Espaço em Disco

Wed, 13 Jun 2007 17:19:00 -0300

Um problema comum de qualquer administrador é o espaço em disco. As politicas de quotas geralmente resolvem boa parte destes problemas, é claro, mas nem sempre são suficientes.

O caso: pensando de forma genérica, diversas pessoas criam diretórios de trabalho dentro do bom e velho/local e, com o passar do tempo, esta partição pode lotar e comprometer o trabalho de todos. Politicas de uso racional do espaço em disco podem ser aplicadas mas as vezes a coisa pode sair do controle -- nesse caso o prejuizo pode ser grande.

Os diretorios possuem o seguinte formato:

/local/diretorio/algum_nome_identificador.vws

Vamos recorrer ao bom e velho Shell-Script para investigar se existe algum problema em andamento!

$ df /local
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sdb1 35001508 11330452 21893064 35% /local

Vejam só: apenas 35% da partição está sendo ocupada e isso não representa risco neste momento. Se estivesse acima de 80% alguma medida perventiva deveria ser tomada. Como podemos fazer este teste? Existem varias formas, vou usar o poder das expressões regulares para isso!

$ seq -f"%g%%" 10 5 100 | grep -E '(100|[89][0-9])%'

80%
85%
90%
95%
100%

A expressão usada no grep casa com valores de porcentagem acima de 80% (inclusive), logo podemos usar em um teste simples

 if df /local | grep -qE '(100|[89][0-9])%' ; then
 echo '/local [quase] lotado!'
 else
 echo '/local seguro (menos de 80%)'
 fi

Simples, não? Poderia ter usado os operadores && e || mas não queria sacrificar a legibilidade do código.

Agora vem a parte divertida: e se o /local estiver ficando cheio, vamos fazer o que?

Quando vc não tem a responsabilidade de apagar arquivos desnecessários, o maximo que vc pode fazer é avisar os responsáveis. Elaborar um relatório com os 'problemas' encontrados e enviar por email usando shell script é simples.

Vamos usar o du para calcular o espaço gasto em cada diretório e o sort para ordenar do maior para o menor tamanho total.

$ du -bs /local/diretorio/* 2>&- | sort -nr 
3765643919 /local/diretorio/nonono001.vws
2290883178 /local/diretorio/nonono002.vws
2067295469 /local/diretorio/nonono003.vws
932165874 /local/diretorio/nonono004.vws
...
267271 /local/viewstore1/nonono999.vws

Facil heim ? Se vc se dá ao trabalho de ler as man pages do du e do sort, basta fazer algumas experiências até obter o resultado que mais lhe agrada. Por exemplo, uma atitude interessante seria listar os X maiores diretórios e enviar por email para o administrador.

$ du -bs /local/diretorio/* 2>&- | sort -nr | head -10 > /tmp/arquivo.log 
$ mailx -S "Lista dos 10 maiores diretorios" "administrador@server" < /tmp/arquivo.log

Talvez vc pergunte o motivo pelo qual eu utilizo um arquivo temporário: caso o envio do email dê algum problema, é possivel recuperar a lista.

Um script para rodar na cron e enviar o email de forma automatizada teria este formato:

#!/bin/bash
# Autor: Tiago Peczenyj - 13/jun/2007
# Script parametrizado para avaliar tamanho de alguns diretorios

X=10
DIR=/local/diretorio
EMAIL=administrador@server
SUBJECT="Lista dos ${X} maiores diretorios em $(date +"%Y%m%d" )"
if df ${DIR} | grep -qE '(100|[89][0-9])%' ; then
 du -bs ${DIR}/* 2>&- | sort -nr | head -${X} > /tmp/arquivo.log 
 mailx -S "${SUBJECT}" ${EMAIL} < /tmp/arquivo.log
fi

O script parece simples, entretanto algo simples como informar o usuario dono de cada diretório é muito mais complexo. A minha solução foi esta:

paste -d '\t' <(du -bs /local/viewstore1/* 2>&-) \
<(ls -l /local/viewstore1 | awk '/^d/{print $3}') | awk '{
 OFS="\t" ; print $1,$3,$2
}'| sort -nr

Um Caracter Inconveniente

Tue, 12 Jun 2007 17:19:00 -0300

Não é incomum passar pelo problema de tentar apagar um arquivo cujo nome começa com o caracter '-', como no exemplo abaixo:

$ rm -arquivo.txt
rm: invalid option -- a

Não adianta proteger a string pois não é o Shell que atrapalha a ação, e sim o próprio programa que reconhece o símbolo - de uma forma diferente. O programa rm aceita, alem de uma lista de arquivos para apagar, uma série de opções que modificam o seu funcionamento. As mais comuns são:

 -f ignore nonexistent files, never prompt
 -i prompt before any removal
 -r remove the contents of directories recursively
 -v explain what is being done

As opções normalmente pode ser colocadas em qualquer lugar da lista de parâmetros.

$ rm -v a.out
removed `a.out'

$ rm a.out -v 
removed `a.out'

Quem avalia os parâmetros normalmente é uma função chamada getopt (presente em várias linguagens, inclusive no Bash). Bom, vimos que o - é um caracter especial para o getopt, mas existe alguma forma de burlar isso?

Sim! O proprio getopt prove essa funcionalidade: o uso dos simbolos '--'. Eles interrompem a expansão de parâmetros e tudo o que vier depois desses dois caracteres será interpretado literalmente pelo programa.

Assim sendo:

$ rm -v -- -arquivo.txt
removed `-arquivo.txt'

Esta dica está no help do comando rm e vale para todos os programas que usem getopts.

Comments

La Batalema Pitonisto

É Tiago,

Nunca caí nessa do arquivo começado com sinal de menos, não por ser mais esperto que os outros, mas porque sou uma traça de manual. =)

Basta um man rm para resolver o problema (foi o que fiz na primeira vez em que me deparei com um arquivo desses).

Mas sabia que existe um livro que muitos chamam de «A Bíblia Negra do Hacker» (creio que a alcunha correta seria «o livreto negro de bolso do lammer»)? Esse livro apresenta a questão do «ataque» (ó! pretenção) onde o «atacante» (uf!) usa :> para criar arquivos começando com sinal de menos, cuja única forma de resolver o problema, segundo o livro, é mover todos os demais arquivos para outro diretório e apagar (argh!) o diretório onde estão os arquivos maliciosos.

É de se escangalhar de rir… um verdadeiro livreto de piadas sujas.

[]'s
Cacilhas

Ola Mundo!

Mon, 11 Jun 2007 16:42:00 -0300

Quando aprendemos uma nova linguagem de programação, normalmente o primeiro exemplo é o famoso "Hello World!", ou seja, um pequeno código que imprime uma mensagem na tela do computador.

Em C, ele seria assim:

/* Um comentário */
#include <stdio.h>

int main ()
{
 puts ("Hello world!");
 return 0;
}

As vezes o puts é substituido pelo multifacetado printf no exemplo, mas o efeito é o mesmo. Vejamos como seria em Java.

/* Comentarios, igual ao C */
package Hello;

public class HelloWorld {
 public static void main(String[] args) {
 System.out.println("Hello world");
 }
 }

As diferenças são várias, apesar da estrutura ser semelhante. Em C nós temos funções parametrizadas, enquanto em Java nós temos objetos (System.out) e métodos (println).

Por fim, vamos ver um exemplo em Shell Script

#!/bin/bash
# comentario
echo "Hello World!"

Diferente de uma linguagem de programação, aqui o interpretador de comandos (normalmente) chama um programa capaz de escrever mensagens para o usuario. Ou seja, alguem ja escreveu um "Hello World!" genérico o suficiente para nós.

Cada linguagem possui um propósito. Enquanto vc projeta sistemas operacionais e drivers em C, Java ocupa uma área no desenvolvimento de grandes sistemas corporativos enquanto o shell está presente na administração de determinadas tarefas de um servidor (normalmente rodando algum sabor de *nix).

Não basta comparar um hello world, pois é preciso ver muito além da sintaxe e recursos da linguagem, mas normalmente se começa por ele.

Outros exemplos podem ser encontrados aqui.

Abraços