Array no Perl

Um tipo de variável comum em quase todas as linguagens de programação é a Array. Vamos aprender como utilizá-la dentro do Perl.

As Arrays (arrêis) são um tipo de variável que armazenam dados em forma de lista. Cada objeto da lista é chamado de elemento, e estes elementos – no Perl – podem ser tanto strings como numéricos, ou qualquer outro tipo de dados inclusive uma outra variável.

Criando um Array

  1. Uma array é declarada no Perl com o símbolo (@).
  2. Após o simbolo, informamos o nome, por exemplo, @meses.
  3. Para definirmos os valores, devemos então abrir um colchete “(“.
  4. Definimos os valores. (Se for string, podemos colocar entre aspas)
  5. Fechamos a lista com o  colchete “)”

Esta é a simples síntaxe dos arrays no Perl. Quando estamos listando os valores da lista, podemos quebrar ela em várias linhas para que fique fácil de entender, porém, não podemos esquecer de fechar o colchete que informa ao Perl que a lista se encerra ali.

Exemplo:

@meses = (“Janeiro”,
   “Fevereiro”,
   “Março”,
   “Abril”,
   “Maio”,
   “Junho”,
   “Julho”,
   “Agosto”,
   “Setembro”,
   “Outubro”,
   “Novembro”,
   “Dezembro”);

 Acessando um Array

Depois que criamos o array, todo o conjunto poderá ser acessado se chamarmos @meses, mas se quisermos também podemos acessar o conteudo de apenas um ítem da lista informando sua devida posição da seguinte forma: $meses[POSICAO] onde POSICAO é a ordem que o ítem ocupa na lista.

Toda lista começa sempre em 0 (zero).

Agora digamos que queremos mostrar ao usuário o mês de Janeiro na tela.
Devemos apenas chamar a variável, da seguinte forma:

print $meses[0];

Informamos assima posição 0 (zero) porque Janeiro é o primeiro elemento da lista. 

E para acessar o último elemento da lista?

 print $meses[11];

Isto irá mostrar Dezembro. Porque Dezembro é o ítem que ocupa a 11º posição da lista @meses.

Tamanho de um Array

Se quisermos mostrar o tamanho de um Array, devemos apenas chamar o nome da Array da seguinte forma: $#array. Isto irá retornar o número de elementos que estão na lista.

Mas lembre-se de que o Perl considera o zero como o primeiro elemento da lista.

No nosso exemplo então, ele retornaria 11 (onze). Caso quisermos obter o número real, podemos usar a expressão $#array + 1;
Se isto fosse feito em nosso exemplo, teríamos como resultado o número 12, porque nossa lista contém 12 elementos se contarmos a partir de 1.


Veja um exemplo completo:
(array.cgi)

#!/usr/bin/perl
print “Content-type:text/html\n\n”;

@meses = (“Janeiro”,
   “Fevereiro”,
   “Março”,
   “Abril”,
   “Maio”,
   “Junho”,
   “Julho”,
   “Agosto”,
   “Setembro”,
   “Outubro”,
   “Novembro”,
   “Dezembro”);
print “O ano começa em “.$meses[0];
print “<br />”;
print “O Natal é um feriado do mês de “.$meses[11];
print “<br />”;
print “O número de meses de um ano é “.($#meses+1);


Anúncios

Split: Dividindo uma String

21 fevereiro, 2009 2 comentários

Uma tarefa muito comum quando utilizamos o Perl para manipular textos é o de separar e dividir uma String – seja ela uma palavra ou uma frase. O split é uma função nativa do Perl que realiza com extrema eficiência esta tarefa. Dado uma String e uma condição, ele realiza uma varredura na String a procura de algo que corresponda o que for definido na regex da condição. Conforme vão sendo encontrados resultados, o split vai retornando os mesmos. Veja sua sintaxe:

($retorno1,$retorno2) = split (/[condição]/,$frase,$limite);

  • As variáveis $retorno1 e $retorno2 receberão os dois dados que forem separados, cada um para a respectiva variável.
  • A condição pode ser expressa em forma de String ou expressão regular (regex) (Veja a tabela de regex).
  • O limite é um parâmetro opcional que só precisa ser definido se for necessário limitar o número de retornos.

No split podemos especificar quantas variáveis de retorno quisermos. Se o número de dados retornados for indefinido, podemos definiro retorno para uma array, da seguinte forma:

(@retornos) = split (/[condição]/,$frase,$limite);

Vejamos alguns exemplos práticos sobre como funciona o split:

$frase = “Campinas – SP”;
($cidade,$estado) = split(” – “,$frase); # Divide a frase por ” – ”

print “Eu moro em $cidade que fica no estado de $estado”;

O exemplo acima produzirá o seguinte resultado:

Eu moro em Campinas que fica no estado de SP


Podemos também usar regex para expressar as condições.
Digamos que temos uma String e queremos separá-la pelos números contidos nela.
Podemos usar a regex d+ que identifica os numeros contidos na String. Veja um exemplo:

$frase = “ABC1DEF2GHI”;
($div1,$div2,$div3) = split(/d+/,$frase,3);

print $div1.”n”;   print $div2.”n”;   print $div3.”n”;

O código acima mostrará o seguinte na tela:

ABC DEF GHI


Como último exemplo, podemos fazer uma separação de vários ítens de uma String.
Vamos pegar uma frase longa que não sabemos o número de retornos.

$frase = “O-rato-roeu-a-roupa-do-Rei-de-Roma”;
(@novaFrase) = split(/-/,$frase); # O retorno é feito na array @novaFrase

print $novaFrase[0].”n”;
print $novaFrase[1].”n”;
print $novaFrase[2].”n”;
(…)
print $novaFrase[8].”n”;

Isto irá separar a frase por e produzirá o seguinte resultado na tela:

O rato roeu a roupa do Rei de Roma

Note que não informamos ao split o número de variáveis que seriam retornadas e nem mesmo o limite, pois  tudo que ele for encontrando ele já vai incluindo na array especificada.
Para obtermos o valor, basta acessar o array informando suas respectivas posições para encontrar os ítens retornados.

Enfim, o split é certamente uma das funções mais importantes do Perl, e um fator que faz de nossa linguagem ser a melhor quando o assunto é manipulação de texto.

Até a próxima!

CGI/Perl no Apache

24 outubro, 2008 Deixe um comentário

O Apache é um dos servidores mais utilizados no mundo.

Por se adaptar em vários sistemas operacionais, ser seguro e por ser livre este servidor é, com certeza, o mais popular da web.

Seu problema é que muitas vezes usuários inexperientes encontram dificuldades ao configurá-lo para trabalhar com uma linguagem de programação, como o Perl por exemplo.

Uma alternativa seria baixar um kit já configurado. O XAMPP poderia ser uma solução.
O único problema é que você baixa programas que talvez não vá utilizar, como o MySql e o PHP.

Neste tutorial iremos ver as etapas para fazer todo o trabalho manualmente.


  1. Baixe o interpretador o Apache e o Perl

    ActivePerl 5.10
    Apache 2.x 

  2. Instalando o Apache

    Os primeiros passos da instalação são realmente simples. No terceiro passo precisamos fazer uma configuração. Aqui definimos o nome do servidor. A imagem abaixo mostra uma configuração recomendada:

    Configuração do Apache

    Feito isso, selecionamos, na próxima etapa, o modo ‘Custom’ pois queremos definir o local onde o apache será salvo. 

    Ao avançar, clique em ‘Change’ e altere o caminho para ‘C:apache’ ou para um caminho que irá facilitar o seu acesso.

    Prosseguindo você irá finalizar a instalação.
    A segunda etapa foi finalizada.

  3. Instalando o ActivePerl

    O processo de instalação do ActivePerl não é complicado. Lembre-se de instalar os PPMs 2 e 3.

    Selecione todas as opções da sessão ‘Choose optional setup actions‘.

    Avance até o fim do processo de instalação.

  4. Configurando o Apache para ler .CGI

    Abra com um editor de texto (Bloco de Notas) o arquivo httpd.conf do Apache, que está dentro da pasta conf.

    Vá até a linha 391 e procure por:

    #AddHandler cgi-script

    e substitua por:

    AddHandler cgi-script .cgi .pl

    Reinicie o Apache clicando no ‘Ícone da Bandeja > Apache > Restart’

Dessa forma seu servidor está pronto para rodar arquivos CGI e PL.
Para fazer um teste, crie o seguinte arquivo:

teste.cgi

#!C:/perl/bin/perl.exe
print “Content-type:text/htmlnn”;
print “Olá Mundo!”;

Adicione-o na pasta ‘cgi-bin’ do apache, e acesse pelo seu browser:
http://localhost/cgi-bin/teste.cgi

Se aparecer a mensagem ‘Olá Mundo!’, CONGRATULATIONS!!!
Seu servidor Apache foi configurado com sucesso! 

On the Fly – O Que É?

4 agosto, 2008 8 comentários

On the fly é uma expressão em inglês que têm como significado os termos: dinâmicamente, às pressas, sempre mudando.

Em termos de programação, o On-the-fly significa algo criado, ou modificado dinâmicamente somente quando requisitamos.

Um exemplo de sistema on-the-fly é o validador de códigos em imagem.

Este tipo de validador, gera uma imagem diferente a cada atualização da página. É imprevisível quantas imagens um usuário poderá necessitar até que este entre com um código correto, por isso não faz sentido armazená-las, pois caso contrário, em um grande site, isto facilmente poderia causar uma sobrecarga.

Mas o On-the-fly resolve esta questão! Uma vez que a imagem fora criada, esta permanesse apenas no cache do usuário. Caso este venha a atualizar a página, uma nova imagem é gerada.

Veja funcionando:

[ Validador On-the-Fly


 

Veja o Código Completo:
(validador.cgi)

 #!/usr/bin/perl
use CGI;
use CGI::Carp “fatalsToBrowser”;
use Image::Magick;
###########################################################

$format = “jpeg”; # Formato de saída

$qs = $ENV{QUERY_STRING}; # Pegamos a querystring

## Lemos o buffer
read(STDIN, $buffer, $ENV{‘CONTENT_LENGTH’});
@conteudo2 = split(/&/, $ENV{QUERY_STRING});
foreach $par (@conteudo2) {
        ($campo, $valor) = split(/=/, $par);
        $valor =~ tr/+/ /;
        $valor =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack(“C”, hex($1))/eg;
        $QUERY{$campo} = $valor;
}

$cgi=new CGI( ); # Criamos uma instância em CGI

if (!$ENV{QUERY_STRING}){ # Se não há querystring
   &addcookie; # Gera novo cookie
   &form; # Mostra formulário
}elsif($QUERY{cod}){ # Se há querystring
  if ($cgi->cookie(‘codigo’) eq $QUERY{cod}){
   # Se o código digitado corresponde ao código no cookie
   &addcookie; # Gera novo cookie 
   # Se corresponde, mostra correto
   print  “<font color=green><h3>Código correto!</h3></font>”; 
   &form; # Mostra formulário
  }else{  # Senão
   &addcookie; # Gera novo cookie
   print  “<font color=red><h3>Código errado!</h3></font>”; # Mostra errado
   &form; # Mostra formulário
  }

}elsif($QUERY{gerar}){ # Se mandou gerar….

  $rand=$cgi->cookie(‘codigo’); # Pega o numero que irá mostrar
  $novo  = Image::Magick-> new(size=>’100×65′);
  # Cria imagem com as dimensões desejadas
  $imagem = $novo-> Read(‘gradient:#CCCCCC-#EEEEEE’);
  # Lê a imagem e coloca-a em uma variável com um fundo degradê
  $imagem=$novo-> Raise(‘4×4’); # Adiciona um efeito de relevo
  $imagem=$novo->MotionBlur(angle=>60,radius=>8,sigma=>3);
  # Adiciona um efeito de borrar
  $imagem=$novo-> Annotate( font => ‘/home/www/HATTEN.ttf’,# Caminho para fonte
fill        => ‘black’,             # Cor da fonte
                                                 pointsize  => 20,               # Tamanho da fonte
                                                 gravity      => ‘Center’,       # Alinhamento
                                                 text          => $rand,          # Escreve o número
  );

  print “Content-type:image/$format\n\n”;
  # Imprime o cabeçalho com o devido formato
  binmode STDOUT;                                 
  # Converte a saída para binario

  $imagem=$novo->Write( “$format:-” );
  # Mostra a imagem no formato escolhido

}

sub form{
 # Mostra na tela
 print qq|<p>Digite o código:</p>
 <img src=?gerar=num />
 <form method=’get’>
  <input type=text name=’cod’ size=8>
  <input type=submit value=’ok’>
 </form>
 |;
}

sub addcookie{
   $codigo=int rand(100000); # Pega um número qualquer
   $cookie=$cgi->cookie(-name=>’codigo’, # Novo cookie
  -value=>$codigo,                    
  -expires=>’+1m’,                     # Expira em 1 minuto
  -path=>’/’,
   ); 
   print $cgi->header(-cookie=>$cookie);  # Salvamos o cookie
}

Perl + Image Magick: Exemplo 4 (Gerando Thumbnails)

22 julho, 2008 2 comentários

Se você sempre achou dificil encontrar aquele programa que fizesse de tudo com suas imagens, enfim, sua procura acabou não é mesmo?

Ao acompanhar estes tutoriais você com certeza deve estar convencido da qualidade do IM.

E neste assunto o IM também não poderia ficar de fora – Gerar Thumbnails

O ImageMagick é essencial para redimensionar imagens com qualidade. Além de suportar inúmeros tipos de arquivos, ele transforma nossas imagens em perfeitas cópias remodeladas, e o melhor, sem exagerar no tamanho. Vamos ver passo-a-passo de um exemplo de como redimensionar imagens com ele, e em seguida uma demonstração.

Primeiro, devemos instanciar o módulo

$novo = Image::Magick -> new( );

Em seguida, carregamos a imagem que iremos trabalhar

$novo -> Read(“$caminho”);

Agora vamos obter as dimensões da imagem

($largura, $altura) = $novo -> Get(‘width’, ‘height’);

Tendo sido definida a nova largura, fazemos uma regra de três para obter a dimensão final restante, no caso a altura final

$n_a=($n_l*$altura/$largura);

Agora, a função que realiza todo o trabalho, Resize

  $nova_imagem  = $novo -> Resize(
  width => $n_l,
  height => $n_a,
  );

Enfim mandamos escrever a nova imagem

$nova_imagem = $novo -> Write(“$saida/thumb.jpg”);

Pronto, você agora tem um redimensionador de imagens da melhor qualidade! Se comparando com o GD, podemos notar como o ImageMagick é capaz de suavizar os pontos da imagem, tornando-a assim muito mais nítida. Veja: 


 

 

Imagem Original

Imagem Original

 

 

Imagem redimensionada usando GD

Resultado: Usando GD

 

 

Usando ImageMagick

Resultado: Usando ImageMagick

 

 


 

 

Veja o Código Completo:
(im-exemplo4.pl)

#!/usr/bin/perl
use Image::Magick;
$caminho =”/home/imagem.jpg”; # Imagem Original
$saida= “/home”; # Saída da Thumbnail
$n_l=”90″; # Nova largura que a thumbnail terá

##############################################################
$novo = Image::Magick -> new( ) or die $!; # Cria imagem
$novo -> Read(“$caminho”); # Lê a imagem

($largura, $altura) = $novo -> Get(‘width’, ‘height’); # Pega as dimensões

$n_a=($n_l*$altura/$largura); # REGRA DE TRÊS

#### Redimensiona ####
$nova_imagem = $novo -> Resize(
width => $n_l,
height => $n_a,
);
#####################

$caminho =~ s/.*(/|\)//gi; # …Queremos só o nome da imagem
$nova_imagem = $novo -> Write(“$saida/thumb_$caminho”);
print “Thumbnail gerada com sucesso!”;

##############################################################

 Image Magick
[ 1 | 2 | 3 | 4 | 5 ]