Curso de Perl – Como programar em Perl parte II
LEMBRETE
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.