Para você que tem uma impressora USB, e precisa que ela se comporte como LPT1, aí vai um dica bastante simples e funcional, que vai fazer você deixar de gastar muitos reais com programas milagrosos.

Para ele funcionar como LPT1 faça o seguinte :

- Vá em compartilhar impressoras e compartilhe
- Coloque um nome nela, por exemplo lx300
- Vá ao iniciar > executar e digite lá cmd
- Digite hostname e anote o resultado, vamo supor que apareça PC1

Então faça a seguinte mágica.

Ainda no cmd digite :

net use lpt1 \\pc1\lx300 /persistent:yes

Onde,

pc1 = nome do seu pc
lx300 = nome de compartilhamento da sua impressora
/persistent:yes = é para impressora permanecer como LPT1 assim que seu pc for reiniciado.

Bem, com isso, você poderá imprimir normalmente “usando LPT1″

Viu como foi fácil !

Espero que tenham gostado !

Tirem suas próprias conclusões

Pois é, um amigo meu me enviou uma página muito interessante. A página lembra muito o Windows 3.1, deu até para matar a saudade.

Vejam no link abaixo:

Página que emula o Windows 3.1

Interessante demais, vale a pena conferir.

Essa é uma dica rápida.

Se você está precisando trocar a ordem de seus sistema operacional no Grub2 e não tem muita experiência com o Grub2, recomendo a vocês o StartupManager, para baixá-lo basta proceder da seguinte forma no Ubuntu

# aptitude install startupmanager

Depois de instalado, vá para seu ambiente gráfico, abra um terminal, e como root digite :

# sudo startupmanager

ou

# startupmanager

Uma tela vai se abrir, escolha o sistema operacional que você deseja colocar em primeiro e feche a tela. No próximo boot a ordem já deverá ter mudado.

Espero que tenham gostado.

Abraços !

O que motivou a escrever esse post, foi a minha visita ao Youtube canal 3D. E também a nova moda do cinema: Os filmes 3D

Vejam um exemplo de filme 3D no Youtube:

Não faz muito sentido você entrar num canal 3D sem ter um óculos especial para isso, não é ?!

NÃO !

Não se você conhecer a técnica de assistir filmes 3D, sem óculos especiais

Voltemos um pouco no tempo, e paremos na era do livro “Olho Mágico”. Lembraram ? Se você leitor, não gostava muito de frequentar livrarias e bibliotecas, talvez não conheça, então vou lhes apresentar:

Te parece familiar ?!

Pois bem, a visualização da imagem 3D escondinda dentro da figura é possível da seguinte forma, fixe os olhos na imagem, e tentem olhar através dela. Com algum tempo, a imagem vai começar a se destorcer, e como num passe de mágica, uma imagem tridimensional, surgirá diante de seus olhos.

No ínicio leva-se um certo tempo até acostumar a ver essas figuras, mas depois fica bem fácil.

Agora a parte científica.

Essa técnica de inserir imagens 3D em figuras, chama-se : Estereograma. Buscando o verbete na Wikipédia encontrei :

Um estereograma é uma técnica de ilusão de óptica, onde a partir de duas imagens bidimensionais complementares, é possível visualizar uma imagem tridimensional. Basicamente deve-se ver cada uma das duas imagens bidimensionais com um dos olhos, gerando-se a ilusão da tridimensionalidade.

Há anos, os estereogramas têm sido feitos sobrepondo-se fotografias com tomadas de ângulos ligeiramente distintos. Atualmente voltaram à fama, graças aos RDS (Random Dot Stereogram), criados com softwares específicos.

Para conseguir enxergar um estereograma, o principal é conhecer o resultado esperado. A idéia é desfocar a vista da imagem, de maneira que ambas as perspectivas sejam captadas. Alguns recomendam olhar o infinito, ou seja, fitar a vista num objeto distante e, sem desfocar, voltar a olhar a imagem. Outros preferem fitar a visão em um dedo sobre a imagem e lentamente retirá-lo, ou observar o reflexo da imagem num vidro, ou olhar a imagem bem de perto e, mantendo o foco, ir afastando a cabeça, de forma que o foco saia do papel até encontrar o ponto ideal. Depende de cada pessoa e sua condição visual. Alguns estereogramas já trazem um auxílio, como dois pontos, onde você foca a sua visão de forma que os 2 pontos se transformem em 3, então a imagem pretendida aparecerá.

Então ?! Viram como é fácil ver filmes em 3D sem precisar dos óculos especiais ? Basta treinar os olhos um pouco e vocês nunca mais precisaram de óculos 3D

Bem, espero que tenham gostado.

Esse é mais um post relâmpago.

Para aqueles que gostariam de instalar o Oracle XE no Ubuntu, ou em outro sistema Debian-Like, basta executar os procedimentos abaixo :

Adicione essa linha ao seu repositório, que ficam em : /etc/apt/sources.list

deb http://oss.oracle.com/debian unstable main non-free

Importe a chave com o seguinte comando :

# wget http://oss.oracle.com/el4/RPM-GPG-KEY-oracle -O- | sudo apt-key add –

Faça o update :

# apt-get update

Instale o Oracle XE :

# apt-get install oracle-xe

Depois, basta chamar dessa forma :

/etc/init.d/oracle-xe configure

Na primeira vez que você fizer isso, responda às perguntas.

Se por acaso precisar de saber quais os comandos mais usados basta fazer :

/etc/init.d/oracle-xe TAB TAB

Espero que tenham gostado, e desculpem a correria

Esse é um pequeno artigo, sobre como sincronizar o Palm Z22 com o Ubuntu Linux 8.04.

Nesse artigo vou direto ao assunto, por que estou meio sem tempo, mas vamos lá.

O primeiro passo é o seguinte, como root, faça :

# modprobe visor

Caso você não faça isso, o HotSync não funcionará.

Se você for usar o Palm Z22 direto, aconselho você adicionar esse módulo em /etc/modules. Então você poderá fazer o seguinte :

# echo “visor” >>/etc/modules

Se você tiver a curiosidade de ver como o seu dispositivo é reconhecido faça :

# tail -f /var/log/messages

E conecte o seu dipositivo, você deverá perceber algo parecido com isso :

usb 1-3: Handspring Visor / Palm OS converter now attached to ttyUSB0
usb 1-3: Handspring Visor / Palm OS converter now attached to ttyUSB1

Depois de todas essas operações, vá na aba de Sistema > Dispositivos PalmOS e na parte de Dispositivos, clique em Adiciona.

- Em Nome, coloque o nome que você gostaria que seu dispositivo tivesse;
- Em Tipo coloque USB, pelos menos no meu caso foi assim ;
- Em tempo de expiração deixe 2 mesmo ;
- Em Dispositivo coloque /dev/pilot
- Por fim,a velocidade de 115200

Vocês podem conferir a telinha na figura abaixo :

Ainda nessa tela, em Canais, você poderá escolher o que sincronizar, depois disso, basta apertar o botão de HotSync do seu Palm, para que as aplicações sejam sincronizadas.

Bem, não entrarei em detalhes ( já que esse artigo trata somente de sincronismo ) para não estragar o resto da brincadeira.

Abraços, e espero que tenham gostado.

Para aqueles que estão tentando executar o Nmap no Windows Vista, e estão se deparando com a seguinte mensagem :

dnet: Failed to open device eth4

Seus problemas acabaram

Basta executar o programa no modo Administrador, clicando com o botão direito sobre o ícone, e selecionando :

Executar como Administrador.

É isso aí

Logo voltaremos com mais notícias do tenebroso mundo do Windows Vista.

Começando a série de artigos, Gustavo é Vendido, e agora usa Windows Vista, segue uma diquinha.

Para aqueles desesperados, que não sabem onde Bill Gates enfiou a porra do Telnet no Windows Vista, digite no Executar o seguinte comando :

optionalfeatures

Adicione o Client Telnet, e seja feliz.
Abraços !

O motivo é a falta de espaço

Abraços e deêm uma passadinha por lá

O curso também pode ser acessado em

http://www.linuxchix.org.br/?q=node/99

E também um link para a lista:

http://listas.linuxchix.org.br/mailman/listinfo/cursos

Dessa ve, estarei colocando o código na forma original :

Perl best practices: escrevendo códigos legíveis; Perl modules: instalação,
uso, módulos comumente usados.

ATENÇÃO:
Esta aula faz parte do curso Perl Tutorial e é continuacao do curso Perl
Intro, também disponibilizado no LinuxChix.org.br. Esta aula de forma alguma
cobre todas as informações disponíveis sobre Perl best practices ou Perl
modules.

*** Transformando um código mal formatado/identado em um código mais
legível.

Formatar o código de maneira legível é parte das “boas praticas”
recomendadas para programadores em qualquer linguagem de programação. O fato
é que cada programador tem uma preferência diferente na hora de formatar um
código, o que pode dificultar (e porque não dizer, irritar) a vida de quem
precisa ler/alterar o código que outra pessoa escreveu.

Por exemplo, vejá o mesmo programa formatado de maneiras diferentes:

# FORMATACAO 1:

my $código= “XYZ456475″;
my $data = “2006/04/23″ ;

my $resposta_do_teste =testar_formato_dos_dados ($código,$data );

print “$resposta_do_teste\n” ;

sub testar_formato_dos_dados
{
my($código,$data)=@_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}}
and $código =~ m{[A-Z]{3}\d+}){
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
}
else{ return “Os dados não estao no formato correto” ;
}
}

# FORMATACAO 2:

my $código = “XYZ456475″;
my $data = “2006/04/23″;
my $resposta_do_teste = testar_formato_dos_dados($código, $data);
print “$resposta_do_teste\n”;

sub testar_formato_dos_dados {
my ($código, $data) = @_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}} and $código =~ m{[A-Z]{3}\d+} ) {
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
} else {
return “Os dados não estao no formato correto”;
}
}

# FORMATACAO 3:

my $código = “XYZ456475″;
my $data = “2006/04/23″;

my $resposta_do_teste = testar_formato_dos_dados($código, $data);

print “$resposta_do_teste\n”;

sub testar_formato_dos_dados {
my ($código, $data) = @_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}} and $código =~ m{[A-Z]{3}\d+} ) {
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
} else {
return “Os dados não estao no formato correto”;
}
}

— Alguns programadores, por exemplo, poderiam achar horrivel de ler um
código usando a FORMATACAO 1 porque esse exemplo não segue um estilo na
formatação.

Num mundo ideal, os programadores de um determinado projeto e/ou equipe
teriam padrões de programacao a serem seguidos. No mundo real – onde a
teoria é por muitas vezes diferente da prática – existe o Perltidy para
facilitar a vida dos Perl programmers:

http://search.cpan.org/~shancock/Perl-Tidy-20060719/bin/perltidy

— PELRTIDY: uma ferramenta muito util para identar e reformatar um código.
Ele lê um script em Perl e reformata/identa o script. Um exemplo bem simples
de uso:

$ perltidy o_seu_script.pl

- Nesse caso, o perltidy lê o conteúdo do o_seu_script.pl e cria um arquivo
chamado o_seu_script.pl.tdy que contém o código original reformatado. O
conteúdo do arquivo o_seu_script.pl permanece inalterado.

Há inumeras opcoes que podem ser passadas para o perltidy para que ele
funcione de acordo com a sua preferencia. Alguns outros exemplos são:

$ pertidy -b o_seu_script.pl

- Nesse caso, o perltidy altera o arquivo o_seu_script.pl e faz um backup do
conteúdo original em o_seu_script.pl.bak.

$ perltidy -gnu o_seu_script.pl

- Nesse caso, o o_seu_script.pl é reformatado num estilo aproximado ao do
GNU Coding Standards para programas em C.

# MAIS informações
Mais informações sobre o perltidy podem se encontradas no CPAN.org (link
citado acima) e nos seguintes links:

http://perltidy.sourceforge.net/stylekey.html

http://perltidy.sourceforge.net/tutorial.html

*** Perl modules: instalações, uso, módulos comumente usados.

### O QUE é?
Falando de uma forma bem simples, um módulo pode ser definido como um
arquivo que contem uma ou mais funcoes. Um módulo pode ou não ser orientado
a objeto – mas antes de falar sobre orientacao a objeto é necessario que se
tenha um bom entendimento sobre módulos. O assunto orientacao a objeto será
abordado laaaaa nas próximas aulas.

OBS.: Se voce não se lembra o que é ou como criar/usar funcoes em Perl, de
uma olhada na aula 4 do curso de introducao ao Perl. E, se continuar em
duvida, mande uma mensagem para o grupo.

### PARA QUE SERVE?
módulos são usados como uma forma de reaproveitamento de código. Assim, se
voce tem várioss programas que utilizam o mesmo conjunto de funcoes, voce
pode colocar esse conjunto de funcoes dentro de um módulo e fazer com que os
seus programas usem esse módulo.

OBS.: O assunto “criando módulos em Perl” será abordado laaaa nas próximas
aulas. Muita calma nessa hora. Por enquanto so será abordado como instalar e
usar módulos que já estao prontos e disponiveis.

Diversos programadores disponibilizam os seus módulos através do CPAN.org.
Alguns módulos já são disponibilizados na propria distribuição do Perl.
várioss outros podem ser baixados no site CPAN.org.

Sendo assim, evite reinventar a roda. Se já existe um módulo que faz o que
voce precisa, não hesite, utilize-o-o-o. Por exemplo, se voce precisa de um
módulo que envie email, antes de escrever o seu código, acesse o
search.cpan.org e procure por mail. Há grandes chances de que já exista um
módulo que faz exatamente o que voce quer, disponível, bem documentado e
testado. não tenha medo de usa-lo.

E ha os tipos de módulos que servem para alterar a forma como o Perl
funciona.

### COMO USAR?
Depende do módulo. Cada módulo vem com uma documentacao explicando suas
funcionalidades e exemplos de como usa-las.

A documentacao pode ser acessada digitando na linha de comando:

$ perldoc NOME_DO_módulo

Por exemplo:

$ perldoc Net::FTP

De forma geral, antes de usar qualquer funcao de um módulo é necessario
declara-lo. Isto é, é necessario “avisar” o seu programa que ele utiliza
funcoes que não estao localizadas dentro do proprio programa, mas sim dentro
de um outro arquivo. Assim como tudo em Perl, ha mais de uma forma de se
fazer isso. Uma delas é usar o operador “use”.

OBS: Se voce não se lembra do operador use, de uma olhada na primeira aula
do curso de Introducao ao Perl. Desde o comeco do curso a orientacao era
para que todos os programas criados comecassem com as linhas citadas abaixo.
Naquela aula eu não dei muitos detalhes do porque e falei que o assunto
seria abordado nas aulas seguintes. A hora chegou.

use strict;
use warnings;

Essas linhas servem para carregar os módulos strict e warnings do Perl.
Ambos são módulos que servem para alterar a forma como o Perl funciona.

O módulo strict obriga a declaracao do escopo das variaveis. Sim, o seu
código vai funcionar mesmo que essa linha sejá omitida. Mas o uso do módulo
strict faz parte do Perl best practices. Usar o strict faz com que o seu
código sejá menos sujeito a erros.

O módulo warnings ativa a emissão de… warnings. Permite que o Perl emita
warnings quando o código tem um erro, mesmo que esse erro não sejá fatal.

Por exemplo:

use strict;
use warnings;

my $numero = 10;
$numero += ‘t’;
print $numero . “\n”;

Esse código contem um erro, mas como esse erro não é fatal, o Perl vai
rodar normalmente. Porem esse código não vai conseguir fazer a conta ” t +
10 ” e vai emitir um warning.

### COMO INSTALAR?

Primeiro verifique se o módulo já não esta instalado na sua maquina. De
novo, ha mais de uma forma de se fazer isso, uma delas é rodar na linha de
comando:

$ perl -MNome_do_módulo -e 1

Por exemplo, se voce não tem certeza se os módulos Net::FTP ou DBD::Oracle
já estao instalados, rode na linha de comando:

$ perl -MNet::FTP -e 1
$ perl -MDBD::Oracle -e 1

Se o módulo não estiver instalado, uma mensagem de erro será mostrada. Se
não aparecer nenhum erro, significa que o módulo já esta instalado.

Ola, todo mundo.

Esta aberta a segunda temporada do curso de Perl: Perl Tutorial.
Nessa fase do curso, serao abordados os assuntos referencias, modulos,
orientacao a objeto, best practices, perl style, entre outros.

A primeira temporada – Perl Intro – esta nos arquivos da lista e podem ser
acessados nos seguintes links:

Aula 1:

http://listas.linuxchix.org.br/pipermail/cursos/2006-March/000002.html

Aula 2:

http://listas.linuxchix.org.br/pipermail/cursos/2006-April/000004.html

Aula 3:

http://listas.linuxchix.org.br/pipermail/cursos/2006-April/000039.html

Aula 4: http://listas.linuxchix.org.br/pipermail/cursos/2006-May/000048.html
Aula 5: http://listas.linuxchix.org.br/pipermail/cursos/2006-May/000050.html

Uma breve apresentacao, para quem nao me conhece: meu nome eh Lucia e eu
moro em Toronto, no Canada. Eu sou Analista de Sistemas e trabalho como
consultora em analise e desenvolvimento de sistemas para empresas de
telecomunicacoes tanto aqui do Canada como dos Estados Unidos.

Para quem ainda nao eh familiar com a apresentacao do curso: as aulas sao
enviadas aproximadamente 1 vez por semana. Quaisquer duvidas a respeito das
aulas devem ser enviadas para o grupo, atraves do e-mail
cursos em linuxchix.org.br.

Qualquer assunto relacionado a programacao, mas nao relacionado ao curso
atualmente ministrado, deve ser enviado para o programacao em linuxchix.org.br.

Eh isso. Fim do bla bla bla.
A primeira aula dessa segunda parte do curso vira na proximo email.

Cheers!
Lucia
————– Próxima Parte ———-
Um anexo em HTML foi limpo…
URL: http://listas.linuxchix.org.br/pipermail/cursos/attachments/20070205/bb6576b8/attachment.html

## Perl Tutorial – Parte 1 ###

Perl best practices: escrevendo codigos legiveis; Perl modules: instalacao,
uso, modulos comumente usados.

ATENCAO:
Esta aula faz parte do curso Perl Tutorial e eh continuacao do curso Perl
Intro, tambem disponibilizado no LinuxChix.org.br. Esta aula de forma alguma
cobre todas as informacoes disponiveis sobre Perl best practices ou Perl
modules.

*** Transformando um codigo mal formatado/identado em um codigo mais
legivel.

Formatar o codigo de maneira legivel eh parte das “boas praticas”
recomendadas para programadores em qualquer linguagem de programacao. O fato
eh que cada programador tem uma preferencia diferente na hora de formatar um
codigo, o que pode dificultar (e porque nao dizer, irritar) a vida de quem
precisa ler/alterar o codigo que outra pessoa escreveu.

Por exemplo, veja o mesmo programa formatado de maneiras diferentes:

# FORMATACAO 1:

my $codigo= “XYZ456475″;
my $data = “2006/04/23″ ;

my $resposta_do_teste =testar_formato_dos_dados ($codigo,$data );

print “$resposta_do_teste\n” ;

sub testar_formato_dos_dados
{
my($codigo,$data)=@_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}}
and $codigo =~ m{[A-Z]{3}\d+}){
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
}
else{ return “Os dados NAO estao no formato correto” ;
}
}

# FORMATACAO 2:

my $codigo = “XYZ456475″;
my $data = “2006/04/23″;
my $resposta_do_teste = testar_formato_dos_dados($codigo, $data);
print “$resposta_do_teste\n”;

sub testar_formato_dos_dados {
my ($codigo, $data) = @_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}} and $codigo =~ m{[A-Z]{3}\d+} ) {
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
} else {
return “Os dados NAO estao no formato correto”;
}
}

# FORMATACAO 3:

my $codigo = “XYZ456475″;
my $data = “2006/04/23″;

my $resposta_do_teste = testar_formato_dos_dados($codigo, $data);

print “$resposta_do_teste\n”;

sub testar_formato_dos_dados {
my ($codigo, $data) = @_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}} and $codigo =~ m{[A-Z]{3}\d+} ) {
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
} else {
return “Os dados NAO estao no formato correto”;
}
}

— Alguns programadores, por exemplo, poderiam achar horrivel de ler um
codigo usando a FORMATACAO 1 porque esse exemplo nao segue um estilo na
formatacao.

Num mundo ideal, os programadores de um determinado projeto e/ou equipe
teriam padroes de programacao a serem seguidos. No mundo real – onde a
teoria eh por muitas vezes diferente da pratica – existe o Perltidy para
facilitar a vida dos Perl programmers:

http://search.cpan.org/~shancock/Perl-Tidy-20060719/bin/perltidy

— PELRTIDY: uma ferramenta muito util para identar e reformatar um codigo.
Ele le um script em Perl e reformata/identa o script. Um exemplo bem simples
de uso:

$ perltidy o_seu_script.pl

- Nesse caso, o perltidy le o conteudo do o_seu_script.pl e cria um arquivo
chamado o_seu_script.pl.tdy que contem o codigo original reformatado. O
conteudo do arquivo o_seu_script.pl permanece inalterado.

Ha inumeras opcoes que podem ser passadas para o perltidy para que ele
funcione de acordo com a sua preferencia. Alguns outros exemplos sao:

$ pertidy -b o_seu_script.pl

- Nesse caso, o perltidy altera o arquivo o_seu_script.pl e faz um backup do
conteudo original em o_seu_script.pl.bak.

$ perltidy -gnu o_seu_script.pl

- Nesse caso, o o_seu_script.pl eh reformatado num estilo aproximado ao do
GNU Coding Standards para programas em C.

# MAIS INFORMACOES
Mais informacoes sobre o perltidy podem se encontradas no CPAN.org (link
citado acima) e nos seguintes links:

http://perltidy.sourceforge.net/stylekey.html

http://perltidy.sourceforge.net/tutorial.html

*** Perl modules: instalacao, uso, modulos comumente usados.

### O QUE EH?
Falando de uma forma bem simples, um modulo pode ser definido como um
arquivo que contem uma ou mais funcoes. Um modulo pode ou nao ser orientado
a objeto – mas antes de falar sobre orientacao a objeto eh necessario que se
tenha um bom entendimento sobre modulos. O assunto orientacao a objeto sera
abordado laaaaa nas proximas aulas.

OBS.: Se voce nao se lembra o que eh ou como criar/usar funcoes em Perl, de
uma olhada na aula 4 do curso de introducao ao Perl. E, se continuar em
duvida, mande uma mensagem para o grupo.

### PARA QUE SERVE?
Modulos sao usados como uma forma de reaproveitamento de codigo. Assim, se
voce tem varios programas que utilizam o mesmo conjunto de funcoes, voce
pode colocar esse conjunto de funcoes dentro de um modulo e fazer com que os
seus programas usem esse modulo.

OBS.: O assunto “criando modulos em Perl” sera abordado laaaa nas proximas
aulas. Muita calma nessa hora. Por enquanto so sera abordado como instalar e
usar modulos que ja estao prontos e disponiveis.

Diversos programadores disponibilizam os seus modulos atraves do CPAN.org.
Alguns modulos ja sao disponibilizados na propria distribuicao do Perl.
Varios outros podem ser baixados no site CPAN.org.

Sendo assim, evite reinventar a roda. Se ja existe um modulo que faz o que
voce precisa, nao hesite, utilize-o-o-o. Por exemplo, se voce precisa de um
modulo que envie email, antes de escrever o seu codigo, acesse o
search.cpan.org e procure por mail. Ha grandes chances de que ja exista um
modulo que faz exatamente o que voce quer, disponivel, bem documentado e
testado. Nao tenha medo de usa-lo.

E ha os tipos de modulos que servem para alterar a forma como o Perl
funciona.

### COMO USAR?
Depende do modulo. Cada modulo vem com uma documentacao explicando suas
funcionalidades e exemplos de como usa-las.

A documentacao pode ser acessada digitando na linha de comando:

$ perldoc NOME_DO_MODULO

Por exemplo:

$ perldoc Net::FTP

De forma geral, antes de usar qualquer funcao de um modulo eh necessario
declara-lo. Isto eh, eh necessario “avisar” o seu programa que ele utiliza
funcoes que nao estao localizadas dentro do proprio programa, mas sim dentro
de um outro arquivo. Assim como tudo em Perl, ha mais de uma forma de se
fazer isso. Uma delas eh usar o operador “use”.

OBS: Se voce nao se lembra do operador use, de uma olhada na primeira aula
do curso de Introducao ao Perl. Desde o comeco do curso a orientacao era
para que todos os programas criados comecassem com as linhas citadas abaixo.
Naquela aula eu nao dei muitos detalhes do porque e falei que o assunto
seria abordado nas aulas seguintes. A hora chegou.

use strict;
use warnings;

Essas linhas servem para carregar os modulos strict e warnings do Perl.
Ambos sao modulos que servem para alterar a forma como o Perl funciona.

O modulo strict obriga a declaracao do escopo das variaveis. Sim, o seu
codigo vai funcionar mesmo que essa linha seja omitida. Mas o uso do modulo
strict faz parte do Perl best practices. Usar o strict faz com que o seu
codigo seja menos sujeito a erros.

O modulo warnings ativa a emissao de… warnings. Permite que o Perl emita
warnings quando o codigo tem um erro, mesmo que esse erro nao seja fatal.

Por exemplo:

use strict;
use warnings;

my $numero = 10;
$numero += ‘t’;
print $numero . “\n”;

Esse codigo contem um erro, mas como esse erro nao eh fatal, o Perl vai
rodar normalmente. Porem esse codigo nao vai conseguir fazer a conta ” t +
10 ” e vai emitir um warning.

### COMO INSTALAR?

Primeiro verifique se o modulo ja nao esta instalado na sua maquina. De
novo, ha mais de uma forma de se fazer isso, uma delas eh rodar na linha de
comando:

$ perl -MNome_do_modulo -e 1

Por exemplo, se voce nao tem certeza se os modulos Net::FTP ou DBD::Oracle
ja estao instalados, rode na linha de comando:

$ perl -MNet::FTP -e 1
$ perl -MDBD::Oracle -e 1

Se o modulo nao estiver instalado, uma mensagem de erro sera mostrada. Se
nao aparecer nenhum erro, significa que o modulo ja esta instalado.

Para os casos que voce precisa de um modulo que nao esta instalado na
maquina, acesse o site do CPAN e faca o download do modulo. Cada modulo tem
instrucoes especificas de instalacao. De um modo geral, sera algo como:

tar xfvz module.tar.gz
cd module
perl Makefile.PL
make
make test
make install

ATENCAO: As instrucoes acima sao apenas um exemplo e nao substituem a
leitura do arquivo README (com instrucoes especificas para a instalacao) que
vem junto com cada modulo.

# MAIS INFORMACOES:

Para acessar a documentacao de um modulo, digite na linha de comando:

$ perldoc NOME_DO_MODULO

Por exemplo:

$ perldoc strict

$ perldoc Net::FTP

*** Exercicios

a) Reveja os codigos desenvolvidos na primeira fase do curso e analise a
formatacao usada.

b) Dos 3 exemplos de formatacao dados acima, qual voce acha mais dificil e
qual voce acha mais facil de ler. Porque.

c) Instale o perltidy. Procure codigos perl (no historico do curso, no
google, etc) e rode perltidy neles experimentado as varias opcoes do
perltidy que estao disponiveis. Descubra qual a melhor configuracao do
perltidy para voce.

d) Verifique se a sua maquina tem um modulo chamado CPAN. Se nao tiver,
acesse o search.cpan.org, procure por esse modulo e instale-o. Acesse a
documentacao do modulo (que estara disponivel na sua maquina uma vez o
modulo esteja instalado) e entenda para que ele serve.

#PROXIMAS AULAS:
Perl functions
Validando/testando codigos
Uso de referencias em Perl
Perl style
————– next part ————–
An HTML attachment was scrubbed…
URL: http://listas.linuxchix.org.br/pipermail/cursos/attachments/20070205/49e7b8d0/attachment.html
## Perl Tutorial – Parte 2 ###

Perl functions: Algumas das builtin functions do Perl explicadas atraves de
exemplos

ATENCAO:
Esta aula faz parte do curso Perl Tutorial e eh continuacao do curso Perl
Intro, tambem disponibilizado no LinuxChix.org.br. Esta aula nao cobre todas
as Perl functions, para obter uma lista completa das mesmas, acesse a
documentacao do Perl.

*** Lembretes

— 1. Documentacao especifica:

- Digite na linha de comando:

$ man perlfunc

- ou para acessar direto o man de uma determinada funcao:

$ perldoc -f nome_da_funcao

— 2. Executando os exemplos dados:

- SEMPRE comece os seus programas com as seguintes linhas:

#!/usr/bin/perl
use strict;
use warnings;

- Copie e cole os trechos de programas de exemplo logo abaixo dessas 3
linhas e salve o arquivo.
- Execute o programa na linha de comando.

— 3. Tirando duvidas

- consulte as aulas anteriores
- envie email para a lista

*** Funcoes para tratamento de strings

— Funcoes: uc, lc, lcfirst e ucfirst

- Exemplo de uso:

my $string = ‘TeM GeNtE QuE EsCrEvE AsSiM.’;
print uc $string .”\n”;
print lc $string .”\n”;

- Resultado ao executar o exemplo acima:

TEM GENTE QUE ESCREVE ASSIM.
tem gente que escreve assim.

- Notas:

uc – retorna a versao em letras maiusculas (uppercase) de uma string
lc – retorna a versao em letras minusculas (lowercase) de uma string
Use a funcao lcfirst para transformar em minuscula apenas a primeira letra
da string
Use a funcao ucfirst para transformar em maiuscula apenas a primeira letra
da string

— Funcao: length

- Exemplo de uso:

my $string = ‘inconstitucionalissimamente’;
print length($string) . “\n”;

- a funcao length retorna o tamanho em caracteres de uma string

- Exercicio:
Execute o exemplo acima; edite o programa e retire os parenteses em torno da
variavel $string e execute o programa novamente; compare os resultados e
entenda o porque de os parenteses serem necessarios nesse caso.

*** Funcoes para tratamento de listas

— Funcao: shift

- Exemplo de uso:

my @os = (“Fedora”, “CentOS”, “Windows”, “HP-UX”, “AIX”, “Solaris”);
print “@os\n”;
shift @os;
print “@os\n\n”;

- Resultado ao executar o exemplo acima:

Fedora CentOS Windows HP-UX AIX Solaris
CentOS Windows HP-UX AIX Solaris

- Notas:

shift – remove e retorna o primeiro elemento de um array

# Na aula 4 do PerlIntro ha outros exemplos do uso do shift.

— Funcao: push

- Exemplo de uso:

my @os = (“Fedora”, “CentOS”, “Windows”, “HP-UX”, “AIX”, “Solaris”);
print “@os\n”;
push (@os, “Ubuntu”);
print “@os\n”;

- Resultado ao executar o exemplo acima:

Fedora CentOS Windows HP-UX AIX Solaris
Fedora CentOS Windows HP-UX AIX Solaris Ubuntu

- Notas:

push – usado para acrescentar um ou mais elementos ao final de um array

— Funcao: qw

- Exemplo de uso:

my @os = qw(Fedora CentOS Windows HP-UX AIX Solaris);
print “@os\n”;

- Resultado ao executar o exemplo acima:

Fedora CentOS Windows HP-UX AIX Solaris

- Notas:

o qw() – faz com que cada elemento dentro do “()” separado por um espaco
seja um elemento de um array

Usar:
my @os = qw/Fedora CentOS Windows HP-UX AIX Solaris/;

eh a mesma coisa que usar:
my @os = (“Fedora”, “CentOS”, “Windows”, “HP-UX”, “AIX”, “Solaris”);

Note que o qw separa um elemento do outro baseado em espacos, entao o qw nao
funciona para elementos compostos por duas ou mais palavras, como por
exemplo:

my @os = (“Fedora Core”, “Sun Solaris”); # indica um array de 2 elementos.

my @os = qw/Fedora Core Sun Solaris/; # indica um array de 4 elementos.

— Funcao: reverse

- Exemplo de uso:

my @os = qw/Fedora CentOS Windows HP-UX AIX Solaris/;
print “@os\n”;
my @os_invertido = reverse @os;
print “Array invertido: @os_invertido\n”;

- Resultado ao executar o exemplo acima:

Fedora CentOS Windows HP-UX AIX Solaris
Array invertido: Solaris AIX HP-UX Windows CentOS Fedora

- Notas:

reverse – num contexto de lista, retorna a lista com os elmentos em ordem
inversa

- Exercicios:

1. Crie um programa parecido com o exemplo acima, mas usando a funcao
reverse num contexto de string, nao de lista. Compare os resultados e
entenda a diferenca de comportamento da funcao reverse quando usada no
contexto de scalar e contexto de lista.

2. Execute o exemplo acima, trocando a funcao reverse pela funcao sort.
Descubra para que serve a funcao sort.

*** Funcoes para tratamento de listas/strings

— Funcao: join

- Exemplo de uso:

my @os_array = qw/usuario senha email homepage/;
my $os_string = join(‘:’, @os_array);
print “$os_string\n\n”;

- Resultado ao executar o exemplo acima:

usuario:senha:email:homepage

— Funcao: split

- Exemplo de uso:

my $string = ‘usuario:::senha:::email:::homepage’;
my ($usuario, $senha, $email, $homepage) = split(/:::/, $string);

print “User: $usuario\n”;
print “Passwd: $senha\n”;
print “E-mail: $email\n”;
print “Home Page: $homepage\n\n”;

- Resultado ao executar o exemplo acima:

User: usuario
Passwd: senha
E-mail: email
Home Page: homepage

- Notas:

join – agrupa os elementos de uma lista em uma string, separados pelo
pattern passado como parametro.
split – quebra/separa uma string, usando como separador o pattern passado
como parametro

O join espera como parametros um delimitador e uma lista. No caso do exemplo
acima, o delimitador usado eh o “:” (dois pontos). Uma serie de outros
delimitadores podem ser usados tambem.

*** Funcoes para tratamento de diretorios:

— Funcoes: opendir, closedir, readdir

- Exemplo de uso

my $dir = ‘/etc’;
my $dir_handle;

opendir ($dir_handle, “<”, $dir) || die “Erro ao abrir diretorio $dir: $!”;

foreach my $file ( readdir($dir_handle) ) {
print “$file \n\n”;
}

closedir ($dir_handle);

- Resultado ao executar o exemplo acima:

Uma lista dos arquivos que estao no /etc do seu computador.

- Notas:

opendir – abre um diretorio para processamento
closedir – fecha um diretorio
readdir – retorna o conteudo do diretorio

*** Funcoes para controle de loops

— Funcoes: next, last

- Exemplo de uso

my $dir = ‘/etc’;
my $dir_handle;

opendir ($dir_handle, $dir) || die “Erro ao abrir diretorio $dir: $!”;

foreach my $file ( readdir($dir_handle) ) {
next if ($file =~ /^\./);
print “$file \n\n”;
}

closedir ($dir_handle);

- Resultado ao executar o exemplo acima:

Uma lista dos arquivos que estao no /etc do seu computador. Porem, os hidden
files (os que comecam com ‘.’) nao serao printed por causa dessa linha de
codigo que eh ate bem auto explicativa:

next if ($file =~ /^\./);

Se um arquivo comeca com “.”, a funcao next eh chamada. E essa funcao faz
com que as linhas de codigo a seguir ate o fim do loop ao qual a funcao
pertence sejam ignoradas e comeca a proxima iteracao do loop.

- Notas:

A funcao last eh usada no mesmo contexto que a funcao next, porem a funcao
last forca uma saida do loop em definitivo. Um exmplo de uso:

last if ($file =~ /^a/);

nesse caso, assim que o loop encontrar um arquivo que comeca com a letra a,
a saida do loop sera forcada.

O comando next eh similar ao continue da linguagem C e o comando last eh
similar ao break do C.

*** Aplicacao pratica de algumas das funcoes citadas

— Programa que le o arquivo /etc/passwd, e imprime os nomes dos usuarios
em ordem alfabetica. Usuarios cujo ID seja igual ou menor que 15 sao
ignorados.

- Um exemplo de como implementar:

my $file = ‘/etc/passwd’;
my $fh;
my @users;

# abre arquivo /etc/passwd
open( $fh, “<”, $file ) || die “Erro ao abrir arquivo $file: $!”;

while (<$fh>) {
my %user;

# le cada linha do arquivo
# separa o conteudo usando : como delimitador
# guarda o resultado em um hash
@user{qw( login passwd uid gid gcos home shell )} = split( /:/, $_ );

# ignora alguns usuarios baseado num criterio
next if ( $user{uid} <= 15 );

# guarda os usuarios em um array
push( @users, $user{login} );
}

# separa o conteudo do array por um \n
# ordena o array
print join(“\n”, sort @users);

close($fh);

*** Exercicios

a) Execute os codigos de exemplo desta aula.

b) Crie um programa que le os arquivos /etc/passwd e /etc/group e imprime o
nome do usuario seguido do nome do grupo ao qual ele pertence.

- Informacoes adicionais:

Para quem nao conhece, o formato do arquivo /etc/passwd eh, por exemplo:

root:x:0:0:root:/root:/bin/bash

As informacoes: login, senha, id do usuario, id do grupo, info sobre o
usuario, home directory, shell sao separadas por “:”.

O formato do /etc/group eh, por exemplo:
root:x:0:root

ou

vfat:x:333:fulana,beltrana

As informacoes: nome do grupo, senha, id do grupo, lista de usuarios que
pertencem ao grupo sao separadas por “:”.

Para mais informacoes sobre o /etc/passwd ou /etc/group, acesse o manual,
por exemplo, digitando na linha de comando:

$ man 5 passwd
$ man group

## Perl Tutorial – Parte 3 ###

Data Structure: references, debugging

ATENCAO:
Esta aula faz parte do curso Perl Tutorial e eh continuacao do curso Perl
Intro, tambem disponibilizado no LinuxChix.org.br. Esta aula nao cobre todas
as informacoes disponiveis sobre estrutura de dados, referencias e code
debugging em Perl; para obter informacoes completas, acesse a documentacao
do Perl.

*** Documentacao especifica:

- Digite na linha de comando:

$ man perlreftut
$ man perldsc

*** Perl references

— O que eh:
Eh uma importante feature do Perl que possibilita o uso de estruturas de
dados mais complexas do que simples arrays ou hashes.
Eh similar a ponteiros na linguagem C.

— Para o que serve:
Entre outras coisas, serve para lidar com estruturas de dados mais
complexas.

Fato eh que um array em Perl so pode conter valores do tipo scalar; o mesmo
vale para os valores das keys de um hash. As referencias sao um tipo de
workaround para esse fato.

Vejamos a lista abaixo, de paises e cidades, como exemplo de como o uso de
referencias torna mais facil a organizacao da mesma em um programa.

Brasil: Sao Paulo
Argentina: Buenos Aires
Brasil: Rio de Janeiro
Canada: Toronto
USA: Boston
Canada: Ottawa
Canada: Montreal
USA: New York
Canada: Windsor

Se voce estava pensando em algo como:

#CODIGO1:

my %paises = (
“Brasil” => “Sao Paulo”, “Rio de Janeiro”,
“Canada” => “Toronto”, “Ottawa”, “Montreal”, “Windsor”,
# etc
);

Think again!

O trecho de codigo acima nao e’ valido, pois ele esta “armazenando” uma
lista em cada key do hash paises, e isso nao eh possivel em Perl.

Uma forma correta de lidar com a estrutura acima, armazenando mais de um
valor em cada key do hash eh atraves do uso de referencias:

#CODIGO2:

my %paises = (
“Brasil” => [ "Sao Paulo", "Rio de Janeiro", ],
“Canada” => [ "Toronto", "Ottawa", "Montreal", "Windsor", ],
# etc
);

### Observe que a sintaxe mudou de um codigo para o outro.
### Observe os “[]”

O simbolo “[]” em torno da lista faz toda a diferenca aqui. Ele retorna uma
referencia para a lista e nao a lista em si. E como toda referencia eh do
tipo scalar, e o valor da key de um hash so pode ser um scalar, o CODIGO2
funciona perfeitamente.

— Sintaxe:

Para usar referencias em Perl eh necessario se familiarizar com uma serie de
sintaxes. Entenda-a-a-as. Estude-a-a-as. Decore-a-a-as. Na duvida, consulte
o man. Lembre-se de que voce nao estara sozinha(o) nesse momento dificil.

- Para criar um arrayref, use [ ]

Ex.:

my $idades = [ 15, 31, 22, 12 ];

- Para criar um hashref, use { }

Ex.:

my $capitais = {
Brasil => “Brasilia”,
Canada => “Ottawa”,
Alemanha => “Berlin”,
};

- Para criar uma referencia de uma variavel ja existente, use \ na frente
dessa variavel:

Ex.:

my @idades = ( 15, 31, 22, 12 );
my $idades_ref = \@idades;

my %capitais = (
Brasil => “Brasilia”,
Canada => “Ottawa”,
Alemanha => “Berlin”,
);
my $capitas_ref = \%capitais;

- Para acessar os valores dentro de uma referencia

Ex. de leitura:

print “O elemento 2 do array idades eh $idades_ref->[2]\n”;
print “A capital da Alemanha eh $capitais_ref->{Alemanha}\n”;

Ex. de gravacao:

$idades_ref->[1] = 54;
$idades_ref->[5] = 30;
$capitais_ref->{Dinamarca} = “Copenhagen”; # criando uma nova
key no hash
$capitais_ref->{Brasil} = “Brasilia, DF”; # alterando uma key
existente

— Outras formas de usar referencias (Perl references e as perl functions
push e keys)

- Exemplo sem o uso de referencias (como ja visto nas aulas anteriores):

push( @idades, 77 );

foreach my $pais ( keys %capitais ) {
print “Pais: $pais\n”;
}

- Exemplo com o uso de referencias:

push ( @$idades_ref, 77 );

foreach my $pais ( keys %$capitais_ref ) {
print “Pais: $pais\n”;
}

### MUITA atencao com os simbolos!!!
### Observe que voce precisa saber que tipo de referencia eh a variavel para
saber qual simbolo usar:

Se for array, use @:
@$array_ref

Se for hash, use %:
%$hash_ref

— Usando como exemplo de estrutura de dados, a estrutura do arquivo
/etc/passwd (vista na aula passada):

login:senha:uid:gid:gcos:home:shell

- Exemplo de conteudo do /etc/passwd:

root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin

- Cada linha do /etc/passwd eh um registro e cada registro tem varios
campos. Organizando esses registros em uma lista, temos como exemplo a
estrutura:

my @passwd = (
{
‘login’ => ‘root’
‘passwd’ => ‘x’,
‘uid’ => ’0′,
‘shell’ => ‘/bin/bash’,
‘home’ => ‘/root’,
‘gcos’ => ‘root’,
‘gid’ => ’0′,
},
{
‘login’ => ‘bin’
‘passwd’ => ‘x’,
‘uid’ => ’1′,
‘shell’ => ‘/sbin/nologin’,
‘home’ => ‘/bin’,
‘gcos’ => ‘bin’,
‘gid’ => ’1′,
},
{
‘login’ => ‘daemon’
‘passwd’ => ‘x’,
‘uid’ => ’2′,
‘shell’ => ‘/sbin/nologin’,
‘home’ => ‘/sbin’,
‘gcos’ => ‘daemon’,
‘gid’ => ’2′,
},
);

- O codigo necessario para chegar nessa estrutura:

###

exemplo();

sub exemplo {
my $users_ref = ler_passwd();
exibir_usuarios($users_ref);
}

sub ler_passwd {
my $file = ‘/etc/passwd’;
my $fh;
my @users;

# abre arquivo /etc/passwd
open( $fh, “<”, $file ) || die “Erro ao abrir arquivo $file: $!”;

while (<$fh>) {

chomp;
my %user;
@user{qw( login passwd uid gid gcos home shell )} = split( /:/, $_
);

push( @users, \%user );
}

close($fh);
return \@users;
}

sub exibir_usuarios {
my ($users_ref) = @_;

foreach my $user (@$users_ref) {
print “O usuario de ID $user->{uid} e’ o $user->{login} e tem home
em $user->{home}\n”;
}
}

###

— Debugging referencias

- Usando o exemplo anterior, carregue o modulo Data::Dumper e faca a
seguinte alteracao:

sub exemplo {
my $users_ref = ler_passwd();
#exibir_usuarios($users_ref);
print Dumper $users_ref;
}

Rode o programa e veja o resultado.

### O modulo Data::Dumper serve para exibir a estrutura completa de uma
variavel, inclusive referencias.

*** Exercicios:

- Dada a estrutura de dados:

my $pessoas = [
{
nome => "Fulano de Tal",
endereco => "Avenida Rua Bairro, 1234",
cidade => "Sao Paulo",
idade => 37,
telefones => {
celular => "907-123-4567",
trabalho => "907-444-3241",
casa => "416-555-9999",
},
filhos => [
{
nome => "Fulaninho Jr.",
idade => 4,
},
{
nome => "Fulaninha",
idade => 9,
},
],
},
{
nome => “Beltrano de Tal”,
endereco => “Avenida Rua Bairro, 87654″,
cidade => “Guarulhos”,
idade => 24,
telefones => {
trabalho => “416-888-3245″,
casa => “416-567-6767″,
},
filhos => [
{
nome => "Beltraninha Baby",
idade => 2,
},
],
},
{
nome => “Ciclano”,
endereco => “Avenida Rua Bairro, 78678″,
cidade => “Sao Paulo”,
idade => 27,
telefones => { celular => “907-787-9595″, },
},
];

Eh possivel fazer, por exemplo, um programa que consulta esses dados e gera
uma lista baseada em certos pre requisitos.

— EXEMPLO1: lista pessoas com idade maior que x

###

sub procurar_pessoas_com_mais_de_x_anos {
my ( $pessoas, $idade ) = @_;

my @pessoas_encontradas;
foreach my $pessoa (@$pessoas) {

if ( $pessoa->{idade} > $idade ) {
push @pessoas_encontradas, $pessoa;
}
}
exibir_pessoas( “Pessoas com mais de $idade anos”, \@pessoas_encontradas
);
# nao se preocupe com esta funcao ainda, apenas entenda que ela vai
exibir pessoas
}

###

— EXEMPLO2: lista pessoas com filhos cuja idade eh menor que x

###

sub procurar_pessoas_com_filhos_com_menos_de_x_anos {
my ( $pessoas, $idade ) = @_;

my @pessoas_encontradas;
foreach my $pessoa (@$pessoas) {

if ( exists $pessoa->{filhos} ) {
foreach my $filho ( @{ $pessoa->{filhos} } ) {
if ( $filho->{idade} < $idade ) {
push @pessoas_encontradas, $pessoa;
last;
}
}
}
}

exibir_pessoas( “Pessoas com filhos com menos de $idade anos”,
\@pessoas_encontradas );
}

###

— O codigo completo desse exemplo:

###

#!/usr/bin/perl

use strict;
use warnings;

exemplo();

sub exemplo {

my $pessoas = [
{
nome => "Fulano de Tal",
endereco => "Avenida Rua Bairro, 1234",
cidade => "Sao Paulo",
idade => 37,
telefones => {
celular => "907-123-4567",
trabalho => "907-444-3241",
casa => "416-555-9999",
},
filhos => [
{
nome => "Fulaninho Jr.",
idade => 4,
},
{
nome => "Fulaninha",
idade => 9,
},
],
},
{
nome => “Beltrano de Tal”,
endereco => “Avenida Rua Bairro, 87654″,
cidade => “Guarulhos”,
idade => 24,
telefones => {
trabalho => “416-888-3245″,
casa => “416-567-6767″,
},
filhos => [
{
nome => "Beltraninha Baby",
idade => 2,
},
],
},
{
nome => “Ciclano”,
endereco => “Avenida Rua Bairro, 78678″,
cidade => “Sao Paulo”,
idade => 27,
telefones => { celular => “907-787-9595″, },
},
];

procurar_pessoas_com_mais_de_x_anos( $pessoas, 25 );

procurar_pessoas_com_filhos_com_menos_de_x_anos( $pessoas, 5 );

} ### sub exemplo

sub procurar_pessoas_com_mais_de_x_anos {
my ( $pessoas, $idade ) = @_;

my @pessoas_encontradas;
foreach my $pessoa (@$pessoas) {

if ( $pessoa->{idade} > $idade ) {
push @pessoas_encontradas, $pessoa;
}
}

exibir_pessoas( “Pessoas com mais de $idade anos”, \@pessoas_encontradas
);
}

sub procurar_pessoas_com_filhos_com_menos_de_x_anos {
my ( $pessoas, $idade ) = @_;

my @pessoas_encontradas;
foreach my $pessoa (@$pessoas) {

if ( exists $pessoa->{filhos} ) {
foreach my $filho ( @{ $pessoa->{filhos} } ) {
if ( $filho->{idade} < $idade ) {
push @pessoas_encontradas, $pessoa;
last;
}
}
}
}

exibir_pessoas( “Pessoas com filhos com menos de $idade anos”,
\@pessoas_encontradas );
}

sub exibir_pessoas {
my ( $titulo, $pessoas ) = @_;

print “\n### $titulo\n”;

foreach my $pessoa (@$pessoas) {
print “$pessoa->{nome} mora em $pessoa->{cidade} e tem
$pessoa->{idade} anos”;
if ( exists $pessoa->{filhos} ) {
print ” e tem ” . scalar( @{ $pessoa->{filhos} } ) . ”
filho(s)”;
}
print “\n”;
}
}

###

- Exercicio 1: execute o programa de exemplo acima.
- Exercicio 2: use o Data::Dumper para imprimir o conteudo da referencia
$pessoas
- Exercicio 3: crie funcoes de busca para listar:

a) Listar pessoas com endereco cujo numero da rua termina em 4
b) Listar pessoas que possuem telefone celular
c) Listar pessoas cujo prefixo do telefone residencial seja 416

- Exercicio 4: Edite o codigo de exemplo e adicione comentarios ao lado de
cada variavel da estrutura $pessoas, identificando de que tipo elas sao.

Ex.:

my $pessoas = [ # array ref
{
nome => "Fulano de Tal", # scalar
endereco => "Avenida Rua Bairro, 1234", # scalar
cidade => "Sao Paulo",
idade => 37,
telefones => { # hashref
celular => "907-123-4567", # scalar
trabalho => "907-444-3241",
casa => "416-555-9999",
},
filhos => [
{
nome => "Fulaninho Jr.",
idade => 4,
},
{
nome => "Fulaninha",
idade => 9,
},
],
},

## Perl Tutorial – Parte 4 ###

Perl style; modules, functions e regexps uteis para tarefas de administracao
de sistemas

ATENCAO:
Esta aula faz parte do curso Perl Tutorial e eh continuacao do curso Perl
Intro, tambem disponibilizado no LinuxChix.org.br. Esta aula nao cobre todas
as informacoes sobre Perl functions, style ou modules. Para obter
informacoes detalhadas e completas sempre acesse a documentacao do Perl.

*** Documentacao especifica:

- Digite na linha de comando:

$ man perlstyle
$ man perlfunc
$ man perlretut
$ man perlvar
$ man perlipc

*** TMTOWTDI – There’s More Than One Way To Do It.

Cada programador tem a sua preferencia na hora de escrever um codigo. Porem
ha algumas recomendacoes gerais que farao com que o seu programa seja mais
facil de ler/entender/debugar/manter. E tao importante quanto saber escrever
um bom codigo eh saber como debugar um codigo.

Recomendacoes gerais:

- o uso dos modulos strict e warnings # como ja foi stressed varias
vezes durante o curso
- uso do modulo diagnostics # para uma explicacao mais
detalhada de um warning, se necessario
- identacao # para a legibilidade
do codigo
- uso do pertidy # para reformatar um
codigo de acordo com a sua preferencia

E lembrem-se, criancas, nao eh porque voce PODE escrever algo em Perl de uma
determinada forma, que voce DEVE escreve-lo dessa forma. O Perl permite
varias formas de se escrever um codigo para uma mesma funcionalidade.
Considere escolher a forma que eh melhor legivel.

*** Perl para sysadmins

— Antes, algumas consideracoes…

- Muita gente (sim, inclusive profissionais de IT) confundem administrador
de sistemas com administrador de redes. Embora o nome ja seja bem auto
explicativo, vale a pena reforcar que administrador de redes, administra
redes (switches, routers, etc); e administrador de sistemas administra
sistemas (Linux, Sun Solaris, MS-Windows, etc). Funcoes completamente
diferentes que exigem conhecimentos diferentes.

- O Perl eh uma ferramenta muito util tanto para adm de redes quanto de
sistemas, mas nessa aula o foco eh o uso do Perl para adm de sistemas.

- Sim, considere usar Perl na hora de criar um programa para automatizar uma
tarefa em vez de usar shell script.

— E alguns exercicios:

A) Escreva um programa que le a saida do “netstat -na” e mostra quantas
conexoes estao estabelecidas (ESTABLISHED) e listening (LISTEN).

B) Faca um programa que coleta informacoes de performance da maquina a cada
10 segundos e salva o resultado num arquivo CSV, no seguinte formato:

unixtime,hostname,loadavg 1min,memtotal,memfree,buffers+cached,swapused

## dica: use como fonte de dados os arquivos:

/proc/loadvg
/proc/meminfo

C) Faca um programa que acessa uma pagina via HTTP e mostra o tempo em
milisegundos que levou para ser acessada. A URL deve ser passada via linha
de comando. Dica: use os modulos Socket, IO::Handle, IO::Socket e
Time::HiRes.

D) Altere o programa anterior e crie um loop onde o programa pergunta a URL
a ser testada ao inves de receber via linha de comando. Quando o usuario
digitar “quit”, saia do loop.

## dica: como falar HTTP:

Exemplo: acessando http://www.exemplo.com/pagina.html
apos se conectar num servidor HTTP, o client deve enviar:

GET /pagina.html HTTP/1.0
Host: www.exemplo.com
(seguido de duas linhas em branco)

Voce pode testar isso usando o comando “telnet www.exemplo.com 80″.

— Nota: as informacoes necessarias para escrever os codigos dos exercicios
estao nesta aula e nas aulas anteriores.

*** Variaveis especiais

As boas e velhas variaveis especiais do Perl.

%ENV
O hash %ENV contem as variaveis de ambiente do seu shell.

- Exemplo:

print $ENV{HOME};
print $ENV{PATH};

- Testando:

Crie um programa que imprime o conteudo do hash %ENV.

@ARGV
O array @ARGV contem os argumentos passados via linha de comando para o
script que esta sendo rodado.

- Exemplo:

Se voce rodar na linha de comando algo como:

./programa.pl argumento1 argumento2

O conteudo de $ARGV[0] sera argumento1 e o conteudo de $ARGV[1] sera
argumento2.

Note que o array @ARGV contem apenas os argumentos, ou seja, aquilo que vem
depois do nome do programa. A variavel especial que contem o nome do
programa em si eh $0.

- Testando:

Crie um programa em perl que imprime o conteudo do array @ARGV. Rode o
programa na linha de comando passando varios argumentos diferentes.
Experimente tbm com parametros como:

./programa.pl argumento1 “argumento2 argumento3″ foo\ bar

*** Lendo dados digitados pelo usuario

STDIN – entrada padrao

- Exemplo

# blah.pl:
print “\n digite algo: \n”;
my $info = <STDIN>;
print “\n Voce digitou: \n $info\n\n”

- Testando:

Rode o blah.pl. Depois rode novamente das seguintes formas:

date | ./blah.pl
uptime | ./blah.pl

*** Executando commandos do sistema

— Funcao: system

— Sintaxe: system COMANDO

— Exemplo:

system “gzip arquivo.txt”

— Notes:

- A funcao system faz um fork antes de executar o comando passado como
parametro e o processo pai espera ate que o processo filho seja finalizado.

- Tenha em mente que o Perl esta a merce do OS no qual ele esta rodando.
Para usar a funcao system, lembre-se de levar em consideracao em qual
sistema o seu programa ira rodar para definir qual o comando a ser passado
como parametro.

- Use o system somente quando necessario. Tenha em mente que o perl tem
varias builtin functions para tratamento de files, como por exemplo:

mkdir
rmdir
chmod
rename
chdir
umask
utime

entre outras…

- Antes de usar a funcao system, consulte o man do perl para verificar se
nao ha uma buitin function do Perl que faz exatamente o que voce quer:

$ man perlfunc

- Para consultar o man de uma funcao especifica:

$ perldoc -f nome_da_funcao

— Funcao: open

— Sintaxe: open $fh, “COMANDO|”

— Exemplo:

open my $fh, “ps uxaw|” or die “Erro ao executar comando: $!\n”;
while (<$fh>) {
print “saida do ps: $_”;
}
close $fh;

— Notes:

Note que a sintaxe do open usada neste exemplo eh um pouco diferente das
sintaxes usadas nas aulas anteriores. O | pipe no final do comando faz com
que ele rode o comando e capture a saida padrao dele.

*** Conectando numa porta TCP

— Funcoes:

socket
connect

— sintaxe:

socket SOCKET,DOMAIN,TYPE,PROTOCOL
connect SOCKET,NAME

— Exemplo:

#socket_exemplo.pl

use Socket;
use IO::Handle;

my $host = shift; # le o parametro passado na linha de comando
my $port = 80;

my $ip_addr = inet_aton($host) or die “host unknown: $host”;
my $paddr = sockaddr_in( $port, $ip_addr );
my $proto = getprotobyname(‘tcp’);
socket( my $socket, PF_INET, SOCK_STREAM, $proto ) or die “socket: $!”;
connect( $socket, $paddr ) or die “connect: $!”;

autoflush $socket;

print $socket “GET / HTTP/1.0\r\nHost: $host\r\n\r\n” or die “print: $!”;

while ( my $line = <$socket> ) {
print “got $line”;
}

close $socket;

— Testando:

./socket_exemplo.pl exemplo.com

*** Expressoes Regulares

— Exemplo para ler e tratar a saida do comando netstat -na

my %count_of;

open my $fh, “netstat -na|” or die “Erro ao executar netstat -na: $!”;
while (<$fh>) {
next if ! /^tcp /;
if ( /\s+(LISTEN|ESTABLISHED)/ ) {
my $qual = $1;
$count_of{$qual}++;
}

}

print ” LISTEN: $count_of{LISTEN}\n”;
print ” ESTABLISHED: $count_of{ESTABLISHED}\n”;

— Notes:

/(LISTEN|ESTABLISHED)/; # da match em LISTEN ou ESTABLISHED

## Perl Tutorial – Parte 5 ###

Fim da 2a parte do Curso de Perl – Overview das ultimas aulas e informacoes
adicionais para referencia; como criar modulos

ATENCAO:
Esta aula faz parte do curso Perl Tutorial e eh continuacao do curso Perl
Intro, tambem disponibilizado no LinuxChix.org.br. Esta aula eh um overview
do que ja foi ensinado nessa fase do curso e de forma alguma cobre todas as
informacoes disponiveis sobre Perl.

*** O que foi abordado nessa fase do curso:

— Perl best practices

- Uso dos modulos strict e warnings
- Formatacao de codigo (definicao de padroes; uso do perltidy)
- Perl style
- Como acessar a documentacao especifica

— Perl modules

- O que eh
- Como instalar (manualmente e usando o modulo CPAN)
- Como usar
- Como acessar a documentacao especifica

— Code debugging

- Uso do modulo diagnostics
- Uso do modulo Data::Dumper

— Perl builtin functions

- Funcoes para tratamento de strings
- Funcoes para tratamento de listas
- Funcoes para manipulacao de arquivos e diretorios
- Funcoes para controle de loops
- Como acessar a documentacao especifica

— Referencias em Perl

- O que eh
- Sintaxe
- Como usa-las para lidar com estruturas de dados mais complexas
- Como acessar a documentacao especifica

— Perl para sysadmins

- Uso do Perl para automatizar tarefas de administracao de sistemas
- Variaveis especiais
- Como receber dados via linha de comando
- Como executar comandos do sistemas usando Perl
- Funcoes uteis para manipulacao de files
- Como se conectar numa porta TCP
- Modulos uteis
- Como acessar a documentacao relacionada

*** Infomacoes adicionais:

— Variaveis especiais

$_ variavel default
@_ argumentos passados para uma subrotina/funcao
$0 nome do programa sendo rodado
@ARGV argumentos passados na linha de comando
%ENV variaveis de ambiente (environment)
@INC path usado pelo Perl para procurar os modulos
$$ ID do processo
$! msg de erro da ultima funcao executada
$| autoflush

$ man perlvar

— Referencias

my $scalar_ref = \$scalar; # retorna a referencia do scalar $scalar
my $array_ref = \@array; # retorna a referencia do array @array
my $hash_ref = \%hash; # retorna a referencia do hash %hash
$$scalar_ref; # dereference um scalar
@$arrayref; # dereference um array
%$hashref; # dereference um hash
my $array_ref = [ ... , ... , ... ]; # cria um arrayref
my $hash_ref = { key => value, … }; # cria um hashref

$ man perlreftut

— Modulos uteis

strict
warnings
diagnostics
Data::Dumper
IO::Handle
IO::Socket
Socket
Exporter
Time:HiRes
DBIx::Class
Storable
LWP::UserAgent
File::Path
HTML::Parser

— Sempre faca:

use strict;
use warnings;
my $variavel; # sempre declare variaveis
open(…) or die $!; # teste o retorno de todas funcoes

- use Perl modules (consulte o CPAN)
- teste o retorno de um comando/funcao
- use variaveis com nome intuitivos
- evite criar variaveis globais
- use perltidy

*** Exercicio: criando um modulo

Entao. Digamos que voce precisa de um modulo com determinadas funcoes e
procurou no CPAN, mas nao encontrou: voce precisara escrever o seu proprio
modulo. Veja abaixo um exemplo de como colocar suas funcoes dentro de um
modulo e como reusa-lo em varios programas.

— Crie o modulo Blah.pm, e escreva algumas funcoes no modulo, seguindo o
modelo abaixo:

package Blah; # nome deste modulo
use strict;
use warnings;
use Exporter; # modulo Perl que facilita a exportacao de funcoes
use base “Exporter”; # conforme a documentacao do Exporter

# liste as funcoes que voce quer exportar
our @EXPORT_OK = qw(
funcao1
funcao2
funcao3
);

sub funcao1 {
my ( $foo, $bar ) = @_;

return $foo * $bar;
}

sub funcao2 {
my ($blah) = @_;
return ucfirst lc $blah;
}

sub funcao3 {
my ($bleh) = @_;
return length $bleh;
}

1; # Perl modules tem que terminar retornando true

— Crie um programa programa.pl que use funcoes do modulo Blah.pm, seguindo
o modelo abaixo:

use Blah qw( funcao1 funcao2 ); # Importe apenas as funcoes que serao
usadas nesse codigo

my $var1 = funcao1( 3, 5 );

print “var1 = $var1\n”;

my $var2 = funcao2(“blAHHHhhhhHHHhhhH!”);

print “Resultado: $var2\n”;

— Rode o programa.pl

####

Fim da 2a parte do curso de Perl.

Para aqueles que sempre tiveram vontade de aprender a programar em Perl, para os mais variados motivos, eis aqui um mini-curso, que dá uma pequena noção sobre como fazê-lo. O Curso foi originalmente escrito pela “lucix at linuxchix org br ( Lucia )”. Vamos ao trabalho, e espero que gostem.

ATUALIZAÇÃO :

Cometi o sacrilégio de esquecer as fontes de consulta, Obrigado Lucia e Sulamita.

O curso também pode ser acessado em

http://www.linuxchix.org.br/?q=node/99

E também um link para a lista:

http://listas.linuxchix.org.br/mailman/listinfo/cursos

Nota, se você não tem acesso a um UNIX para fazer os exercícios ( Ou windows + cygwin ), baixe o programa Perl Active State em http://activestate.com

Introdução

É uma linguagem de programação usada com vários propósitos: Administração de sistemas, desenvolvimento Web, administração de redes, manipulação de dados, textos, e assim por diante.

Documentação

Na linha de comando:

$ man perl

$perldoc -f nome_da_funcao

Na Web :

http://perldoc.perl.org

http://www.google.com.br ( O google sempre ajuda, é só perguntar a ele ).

Rodando programas escritos em Perl na linha de comando.

Obs : Ao escrever um programa em Perl, é interessante que coloquemos a extensão .pl, mas só por enquanto, para podermos lembrar.

Para rodar o programa é simples, basta digitar o nome do interpretador, seguido do nome do programa , exemplo:

$ perl programa1.pl

Sintaxe

Todos os statements terminam com um “;”

Exemplo:

print “Blah, blah, blah”;

Para comentar uma linha, use “#”

Exemplo:

# Isso é um comentario

print “Blah, blah, blah”; # isso também é um comentário

Variáveis

Em perl, existe basicamente 3 tipos de variáveis: scalar, array e hash.

Importante: Você não precisa especificar o tipo de dado que você está guardando dentro de uma variável. Você pode, por exemplo guardar um número e depois guardar um texto que o Perl vai saber como lidar com isso.

scalar : É representado pelo símbolo “$” e é usado para guardar valores simples, como por exemplo: uma palavra, um texto ou números, uma data, etc.

my $fruta = “laranja”;
print “$fruta\n”;

my $total = 24;
my $resultado = $total / 2;
print “$resultado\n”;

array : É representado pelo símbolo “@” e é usado para guardar uma lista de valores.

my @frutas = (“laranja”, “manga”, “banana”);
my @numeros = (10, 45, 20, -78, 99.9, 14);
my @tudo = (“laranja”, 100, 24, “manga”, 5);

my @numeros;
$numero[0] = 10;
$numero[1] = 45;
$numero[2] = 20;
$numero[3] = -78;

Para acessar os elementos de um array, são usados os índices:

print $frutas[0]; # vai imprimir laranja
print $frutas[1]; # vai imprimir manga

Para acessar o último elemento de um array, use $#array_name:

print $frutas[$#frutas]; # vai imprimir banana, que eh o ultimo elemento do
array

hash: É representado pelo simbolo “%” e é usado para guardar uma lista
de valores, assim como o array. O diferencial é que o indice de um array
tem que ser um número. E o indice do hash pode ser um número ou um texto.

Exemplo:

my %idades = ();

$idades{Fulano} = 21;
$idades{Beltrano} = 59;
print “O Fulano tem $idades{Fulano} anos, mas o Beltrano tem
$idades{Beltrano}\n”;

Agora o famoso programa Hello World ! Escrito em Perl:

#!/usr/bin/perl
use strict;
use warnings;

my $texto = “Hello, World!”;
print $texto,”\n”; # imprime Hello, World!

Notas:

1. Tente rodar o programa hello world descrito acima.

2. Sempre começe seu programa em Perl com as seguintes três linhas:

#!/usr/bin/perl
use strict;
use warnings;

Sempre declare as variáveis usando o “my” antes de usa-las ou na primeira
vez que usa-las, exemplo:

my $variavel;
$variavel = “123 testando”;
print “$variavel\n”;

ou então:

my $variavel = “123 testando”;
print “$variavel\n”;

NÃO declare a variável mais de uma vez, como por exemplo:

my $variavel;
my $variavel = “123 testando”;

3. Exercícios:

Crie programas simples de declaração e impressão de variáveis, como por
exemplo:

a) crie um array de 5 elementos e imprima o primeiro e o último elemento;
b) crie um hash cujos indices sejam países e os valores sejam as suas
respectivas capitais. Imprima alguns dos valores;

Operadores, condições e estruturas de repetição – Introdução

Operadores

O Perl tem inúmeros operadores. Os mais comumente usados são:

Matemática:

+ adição
- subtração
* multiplicação
/ divisão
% resto da divisão

Exemplos:

my $x = 5;
my $y = 1.9;
my $z = $y / 2;
my $soma = $x + $y * 3 / $z;
print “Soma: $soma\n”;

my $x = 22;
my $y = 5;
my $resto = 22 % 5;
print “Resto: $resto\n”;

Operadores para comparação numérica:

== igual
!= diferente
maior que
= maior ou igual a

Sintaxe:

if ($numero1 == $numero2) {
…
}

Operadores para comparação de texto:

eq equivalente
ne diferente

Sintaxe:

if ($texto1 eq $texto2) {
…
}

Operadores para comparação lógica:

&& e
|| ou
! negação

Exemplo:

if ( ($numero1 == $numero1) && ($texto1 eq $texto2) ) {
…
}

if ( !($numero1 == $numero2) ) {
…
}

Condições

IF ELSIF ELSE

if (condicao) {

…

} elsif (outra condicao) {

…
} else {

…
}

OU

… if condicao;

Exemplo:

my $sisop = ‘linux’;

if ($sisop eq “solaris”) {

print “Solaris\n”;

} elsif ($sisop eq “linux”) {

print “Linux\n”;

} else {

print “Outro sistema operacional\n”;
}

OU

my $valor = 30;
print $valor if ($valor = 30); #imprime valor SE o valor for igual a 30

UNLESS – eh a negativa do IF.

Sintaxe:

… unless (condicao);

Exemplo:

my $valor = 30;
print $valor unless ($valor = 30); #imprime valor A NÃO SER QUE valor seja
igual a 30

Estruturas de repetição

WHILE: a repeticao continua enquanto “condicao” não for verdade.

Sintaxe:

while (condicao) {
…
}

OU

… while condicao;

Exemplo:

my $contador = 0;
while ($contador 10) {
print “Contando ate 10 com until… $contador\n”;
$contador++; #incrementa contador
}

FOR: é exatamente como na linguagem C. Geralmente nao é muito usado em
Perl, já que o Perl tem uma outra estrutura – o FOREACH – que é muito mais
pratica que o FOR.

for (inicia contador; condicao; incrementa contador) {
…
}

Exemplo:

my $fim = 10;
for ( my $contador=0; $contador “MySQL”,
linguagem => “Perl”,
webserver => “Apache”,
);
foreach my $ferramenta (keys %desenvolvimento) {
print “O Conteudo de $ferramenta eh
$desenvolvimento{$ferramenta}\n”;
}

Exercícios

Para se familiarizar com as estruturas e sintaxes do Perl, crie programas
simples com loops, condições e comparações como por exemplo:

a) crie um array com vários elementos numéricos e imprima somente os números
maiores que 10;

b) crie um array com vários elementos numéricos e imprima somente os números
pares e maiores que 10;

c) crie um array com varios elementos do tipo texto e use foreach para
imprimi-los.

d) crie um programa que contenha as seguintes linhas:

my $resultado = “linux ” x 5;
print “O resultado de linux x 5 eh igual a $resultado\n”;

e veja como funciona a multiplicação de texto.

Tratamento de arquivos e expressões regulares:

ATENÇÃO: Esta aula de forma alguma cobre todas as informações disponíveis
sobre os assuntos: “tratamento de arquivos” e “expressões regulares”. Esses
assuntos serão abordados por várias outras aulas no decorrer do curso. Quem
precisa desesperadamente de mais informações e não pode esperar até que eles
sejam abordados, pode acessar os manuais do Perl, conforme descrito na
primeira aula.

Tratamento de arquivos:

Basicamente o tratamento de arquivos segue a estrutura:

- abre arquivo para escrita e/ou leitura E testa se o arquivo foi aberto
- escreve e/ou le o arquivo
- fecha arquivo

A função open() é utilizada para abrir arquivos, tanto para leitura como
para escrita. E a função close() é usada para fechar os arquivos que foram
previamente abertos.

ABRINDO ARQUIVOS:

Para abrir um arquivo para leitura, pode-se usar algo como:

open(my $arquivo, “/path/do/arquivo.txt”)

NOTA: O símbolo “>” indica que o arquivo está sendo aberto para escrita, e
que o programa vai escrever por cima do que já estiver escrito dentro do
arquivo.

Para abrir um arquivo para escrita (concatenando no final), pode-se usar
algo como:

open(my $arquivo, “>>/path/do/arquivo.txt”)

NOTA: O símbolo “>>” indica que o arquivo está sendo aberto para escrita, e
que o programa vai escrever concatenando o texto no final no arquivo.

TESTANDO SE O ARQUIVO FOI ABERTO:

Para testar se o arquivo foi aberto, pode-se usar algo como:

open(my $arquivo, “) { # le cada linha do arquivo e grava o
conteudo na variavel $linha
print $linha; # imprime o conteudo de $linha
}

Ou então:

while () { # faz um loop lendo uma linha do arquivo de cada vez
e gravando na variavel especial $_
print; # o “print” sozinho eh a mesma coisa que “print $_”
}

Não é magica. Quando nenhuma variavel eh especificada, o Perl usa a
variável especial $_

Sendo assim, na linha do while esta implícito, mas o Perl está gravando cada
linha linha na variável $_ e na linha do print, também está implícito, o Perl
está dando um print na variável $_

ESCREVENDO EM UM ARQUIVO:

Quando um arquivo eh aberto para escrita, como nos exemplos:

open(my $arquivo, “>/path/do/arquivo.txt”);

ou:

open(my $arquivo, “>>/path/do/arquivo.txt”);

Para escrever algo nesse arquivo, pode-se usar algo como:

print $arquivo “1 \n”;
print $arquivo “2 \n”;
print $arquivo “3 \n”;
print $arquivo “4 \n”;

Ou, melhor:

foreach my $numero (1..4) {
print $arquivo “$numero\n”;
}

FECHANDO UM ARQUIVO:

— A função close() é usada para fechar o arquivo que foi aberto tanto
para leitura, como para escrita.

close $arquivo;

Exemplo 1: Lendo o conteúdo de um arquivo:

- Crie um arquivo chamado paises.txt, com o seguinte conteúdo (um país em
cada linha):

Alemanha
Brasil
Dinamarca
Estados Unidos
Inglaterra

- Crie no mesmo diretório onde está o arquivo paises.txt, um programa
chamado paises.pl e copie o seguinte código dentro dele:

#!/usr/bin/perl

use warnings;
use strict;

open (my $arquivo, “) {
print “Nome do pais: $_\n”;
}
close $arquivo;

- Rode o programa na linha de comando:

perl paises.pl

- O programa irá gerar o seguinte output:

Nome do país: Alemanha

Nome do país: Brasil

Nome do país: Dinamarca

Nome do país: Estados Unidos

Nome do país: Inglaterra

Exemplo 2: Escrevendo em um arquivo:

- Para escrever em um arquivo, crie um programa chamado esportes.pl, com o
seguinte conteúdo:

#!/usr/bin/perl

use warnings;
use strict;

open (my $arquivo, “>esportes.txt”) or die “Nao consegui abrir esportes.txt:
$!”;
my @esportes = (“hockey”, “futebol”, “tennis”, “levantamento de peso”,
“baseball”);
print $arquivo “Criando um arquivo em Perl… \n”;
foreach my $esporte (@esportes) {
print $arquivo “Nome do esporte: $esporte\n”;
}
print $arquivo “Fim do arquivo… \n\n”;
close $arquivo;

- Rode o programa na linha de comando:

perl paises.pl

Confira o conteúdo de esportes.txt, que será algo como:

Criando um arquivo em Perl…
Nome do esporte: hockey
Nome do esporte: futebol
Nome do esporte: tennis
Nome do esporte: levantamento de peso
Nome do esporte: baseball
Fim do arquivo…

Expressões Regulares – ou simplesmente “regexp”:

Muita calma nessa hora: Regexps tem fama de serem difíceis e muito
complicadas. Mas a partir do momento que você entende a idéia geral e as
coisas básicas sobre regexps, fica bem mais fácil ir acrescentando
informações e conseguir fazer regexps mais elaboradas.

O que eh uma regexp?

Regexp é um texto que descreve um padrão, um modelo. Por exemplo, é comum
usarmos na linha de comando do linux, algo como: “ls *.pdf”, o que vai
retornar todos os arquivos com extensão “.pdf”. Em Perl existem as chamadas
expressões regulares, que servem para (entre outras coisas que serão
abordadas nas próximas aulas) procurar um determinado padrão dentro de um
texto.

Vejamos através de exemplos:

Vamos pegar o primeiro dos programas de exemplo citado acima:

#!/usr/bin/perl

use warnings;
use strict;

open (my $arquivo, “) {
print “Nome do pais: $_\n”;
}
close $arquivo;

Imagine que você não sabe qual é o conteúdo do arquivo paises.txt, e você quer
imprimir apenas os países cujo nome contem a letra “m”. Para isso,
poderíamos transformar o programa acima em algo como:

#!/usr/bin/perl
use warnings;
use strict;

open (my $arquivo, “) {
if ($_ =~ /m/) { # verifica se o nome do pais contem a letra
m
print “Pais que contem a letra m: $_ \n”;
} else {
print “Pais que NAO contem a letra m: $_ \n\n”;
}
}
close $arquivo;

Analisando o programa de exemplo:

if ($_ =~ /m/) {

O $_ ja foi descrito no começo dessa aula: é uma variável especial do Perl,
muito útil e bastante usada. No caso do programa acima, o conteúdo de $_ é
a linha do arquivo previamente lida durante o statement “while
()”.

=~ é o operador usado para comparar o conteúdo da variavel com a regexp

m eh a regexp (nesse caso, a regex é um texto simples, mas uma regexp pode
ser muito mais complicada do que isso)

Os // no começo e no fim da regexp indica que a letra m será procurada no
conteúdo da variável $_

Em outras palavras o que o programa faz é: verificar se a variável $_
contem a palavra “m”.

Outros exemplos:

my $texto = “Ola Mundo”;
$texto =~ /mundo/; # nao vai dar match pq regexps sao case sensitive.
$texto =~ /a M/; # vai dar match pq espacos sao tratados como qq
outro caractere.
$texto =~ /aM/; # nao vai dar match pq esta faltando o espaco
$texto =~ /Mundo /; # nao vai dar match por causa do espaco no final

Exercicios:

a) Utilizando o programa de exemplo 2: troque a linha:

open (my $arquivo, “>esportes.txt”) or die “Nao consegui abrir esportes.txt:
$!”;

por:

open (my $arquivo, “>>esportes.txt”) or die “Nao consegui abrir esportes.txt:
$!”;

Rode o programa várias vezes. Veja o que acontece com o conteúdo do arquivo
esportes.txt.

b) Exercício terapeutico: Seguindo o programa de exemplo 1 como modelo, crie
um arquivo chamado chatos.txt e coloque nesse arquivo o nome de vários
chatos, um por linha. Faça um programa (chatos.pl) que imprima os nomes dos
chatos.

c) Em Perl, em alguns casos, é possível se imaginar para que serve uma
função baseado no nome da função. Por exemplo: função die – mata o programa;
função use – carrega um módulo, avisa o Perl para “usar” um determinado
módulo. Existe uma função muito útil para ser usada, entre outras coisas,
quando se lê um dado de um arquivo: chomp. Utilizando o programa de chatos
que vc acabou de criar, tente descobrir para que serve o chomp. Tente, por
exemplo:

troque as linhas:

while () {
print “Esse fulano eh um chato: $_ \n”;

por:

while () {
chomp;
print “Esse fulano eh um chato: $_ \n”;

NOTA: Obviamente, só faça esse exercício se você não sabe para que serve o
chomp. Para quem quiser mais informações sobre o chomp: digite na linha de
comando: perldoc -f chomp

d) Ainda utilizando o seu programa de chatos, faça testes com ele: imprima
somente os nomes dos chatos que contém um espaço, que contem a letra m
(maiúscula, depois minúscula), etc.

e) Tente abrir para leitura ( ou >>) um arquivo que não existe. Use o
programa de esportes, por exemplo: apague o arquivo esportes.txt e tente
rodar o programa esportes.pl. Veja o que acontece.

Tratamento de Arquivos, Expressões Regulares e Subrotinas/Funções

ATENÇÃO: Esta aula de forma alguma cobre todas as informações disponíveis
sobre os assuntos: “tratamento de arquivos”, “expressões regulares” e
“subrotinas/funções”. Esses assuntos serão abordados também em outras aulas
no decorrer do curso. Quem precisa desesperadamente de mais informações,
pode acessar os manuais do Perl, conforme descrito na primeira aula.

Ainda sobre o tratamento de arquivos.

Na última aula foi descrito como manipular arquivos para leitura e escrita.
Foram descritas algumas funções nativas do Perl que podem ser usadas para o
tratamento de arquivos, como as funções open e close.

RELEMBRANDO:

- O símbolo é usado para abrir o arquivo para escrita, sobrescrevendo o
conteúdo do arquivo

- O simbolo >> é usado para abrir o arquivo para escrita, acresentando ao
final do arquivo.

ACRESCENTANDO MAIS ALGUMAS INFORMAÇÕES:

- Se o simbolo é omitido, o Perl interpreta que o arquivo está sendo aberto
para leitura.

Exemplo:

open(my $arquivo, “/path/do/arquivo.txt”)

O trecho de código acima, abre o arquivo arquivo.txt para leitura, ou seja,
é a mesma coisa que:

open(my $arquivo, ”
=

Os operadores para comparacao de strings:

eq
ne

Os operadores para comparação lógica:

&&
||
!

As estruturas de condição:

if
elsif
else
unless

As estruturas de repetição:

while
until
for
foreach

Tratamento de arquivos:

- como abrir e ler o conteudo de um arquivo
- como criar/abrir e escrever em um arquivo
- como alterar o conteudo de um arquivo
- como testar se o arquivo foi aberto
- como fechar o arquivo

Expressões regulares:

- como procurar por um padrao em um texto
- como substituir um padrao em um texto

Subrotinas/funções:

- como criar funcoes
- como executar funcoes

NOTA: Quem acompanhou o curso até aqui, supostamente já conhece pelo menos o
básico do que foi descrito acima. Caso você não se lembre de alguma coisa,
revise o conteúdo das aulas anteriores.

Mais informacões sobre expressões regulares:

Back Reference

Back references sao usadas para pegar informacoes especificas de um texto.

Exemplo 1:

Digamos que um programa recebe a seguinte informação:
“hora=10:20,data=25/12/2005″ e que precisamos isolar o dia o mês e o ano em
variáveis diferentes. Podemos usar algo como:

my $info = “horario=10:20,data=25/12/2005″;
my ($dia, $mes, $ano);

if ( $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

$dia = $1;
$mes = $2;
$ano = $3;
print “Dia = $dia\n”;
print “Mes = $mes\n”;
print “Ano = $ano\n”;
}

Ou então:

my $info = “horario=10:20,data=25/12/2005″;
my ($dia, $mes, $ano);

if ( $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

print “Dia = $1\n”;
print “Mes = $2\n”;
print “Ano = $3\n”;
}

Ou ainda:

my $info = “horario=10:20,data=25/12/2005″;

if ( my($dia, $mes, $ano) = $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

print “Dia = $dia\n”;
print “Mes = $mes\n”;
print “Ano = $ano\n”;
}

Analisando trechos do programa:

if ( $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

Esse trecho de código verifica se o conteúdo da variável $info eh um match
para a regexp dada, e guarda os valores entre parentêses nas back
references. Ou seja, o conteúdo da variável $info que da match nas regexps
entre parentêses, são gravadas nas variáveis especiais $1, $2 e $3
respectivamente.

if ( my($dia, $mes, $ano) = $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

Esse trecho de código verifica se o conteúdo da variável $info eh um match
para a regexp dada, e atribui os valores referentes as regexps entre
parentêses para as variáveis $dia, $mes, $ano respectivamente.

Escopo das variáveis: observe que o “my” foi usado dentro de um “if”. Nesse
caso, as variáveis $dia, $mes e $ano, só existem dentro daquele “if”.

Traduzindo a regexp:

m|^.*data=(\d{2})/(\d{2})/(\d{4})|

m|| é o delimitador da regexp, ou seja, indica começo e fim.

^ indica que é o começo da string.

.* “ponto” eh qualquer caractere; “asterisco” indica nenhuma ou mais
ocorrências do caractere anterior. Ou seja, nessa regexp de exemplo, .*
significa: nenhuma ou mais ocorrências de qualquer caractere.

data= neste exemplo, é literalmente o texto “data=”

\d{2} significa a ocorrência de 2 números.

(\d{2}) colocar \d{2} (ou qualquer outro trecho da regexp) entre parentêses,
significa que o conteúdo de variável que der match nesse trecho, estará
acessivel através das back references: $1, $2, $3, $4. etc.

Em outras palavras, essa regexp verifica se:

A string começa com nenhum ou mais quaisquer caracteres seguida de: “data=”,
2 números, uma barra, 2 números, uma barra, 4 números.

Exemplo 2:

Digamos que um programa recebe a seguinte informação: “email=
cursos at linuxchix.org.br” e que precisamos isolar o usuário e o dominio.
Podemos usar algo como:

my $info = ‘email=cursos at linuxchix.org.br’;

if ( $info =~ m|^e-?mail=(.+)@(.+)| ) {

print “Usuario = $1\n”;
print “Dominio = $2\n”;
}

Analisando trechos do programa:

my $info = ‘email=cursos at linuxchix.org.br’;

Note que aqui foi usado ‘ (aspas simples) ao invés de ” (aspas). Isso
porque, em Perl, quando usamos “, significa que o Perl vai interpretar tudo
o que esta dentro de ” (aspas), inclusive variáveis. Então, no exemplo
acima, se fizermos algo como:

my $info = “email=cursos at linuxchix.org.br”;

O Perl vai interpretar o @linuxchix como se isso fosse um array e nao como
se isso fosse um texto qualquer.

Quando usamos ‘ o Perl não tenta interpretar o conteudo entre ‘ (aspas
simples), então podemos usar o sinal @ sem problemas.

Traduzindo a regexp:

m|^e-?mail=(.+)@(.+)|

m|| é o delimitador da regexp, ou seja, indica começo e fim.

^ indica que é o começo da string.

e- neste exemplo, é literalmente a string “e-”

? indica zero ou uma ocorrência do caractere anterior, no caso do exemplo
dado, indica 0 ou uma ocorrência do “-”. Ou seja, vai dar match se a string
começar com “email” ou “e-mail”.

. É qualquer caractere;
+ indica uma ou mais ocorrências do caractere anterior;

Logo:
.+ siginifica: ocorrência de uma ou mais vezes de qualquer caracter

Em outras palavras, essa regexp verifica se:

A string começa com o caractere “e” seguida ou não de um “-”, seguida do
texto “mail=”, seguida de: ocorrência de 1 ou mais quaisquer caracteres, uma
arroba, ocorrência de 1 ou mais quaisquer caracteres.

NOTA: Os exemplos dados são apenas para explicar de forma simples o que é e
como usar back references. Na vida real, para tratamento de datas, emails e
outros tipos de informação padrão, a melhor opção é usar os módulos criados
especificamente para esses fins e disponíveis no CPAN: cpan.perl.org. Não
tente “reinventar a roda”, a não ser, é claro, com o objetivo de aprender.

Exercícios

Antes de começar: se você não sabe do que se trata o arquivo /etc/services,
leia o conteúdo dele e tente entender que tipo de informações são aquelas.

a) Faça um programa que lê o conteúdo do arquivo /etc/services, guarde
somente os nomes dos serviços dentro de um array, somente os números das
portas em outro array e somente o protocolo em um terceiro array. Imprima o
conteúdo dos arrays de forma que a saída do programa seja algo como:

Serviço: telnet – Porta: 23 – Protocolo: TCP
Serviço: http – Porta: 80 – Protocolo: TCP

b) Altere o programa do exercício “a” para que ele imprima a informação
apenas se o protocolo for TCP. Depois altere para que ele só imprima
informação se a porta que o serviço usa for um número par.

c) Faça um programa que lê o conteúdo do arquivo /etc/services. Guarde as
informações de serviços e portas em um hash onde o servico será a key do
hash e a porta que o servico usa sera o value. Imprima o conteúdo do hash no
formato:

Serviço: telnet – Porta: 23
Serviço: http – Porta: 80

d)Altere o programa do exercicio “c” para que ele imprima informação somente
se o nome do serviço não começa com a letra “t” ou “h”.

e) Altere novamente o programa do exercício “c” para que ele imprima
informação somente se a porta na qual o servico escuta seja maior do que
500.

Sei que apesar de ser um problema velho, ela ainda vem atormentando muita gente.

Se você recebeu uma mensagem que seu Windows XP é falso, não se desespere, existe uma forma para combater isso, na verdade 2, por que a segunda seria comprar uma versão original do seu Windows XP.

É bastante simples, basta você clicar aqui e baixar o programa para remover.

São apenas 10 k aproximadamente.

Você deverá baixar o arquivo para sua máquina, e depois executá-lo de qualquer lugar. Feito isso, reinicie a máquina.

Pronto, agora o problema deve ter sumido, e você pode continuar usando o seu Windows XP .

Espero que tenha ajudado, um abraço !