PROBLEMA
Contar ocorrência de uma string em um array em Perl
SOLUÇÃO
Uso do grep e do scalar
EXEMPLO
vamos imaginar o seguinte array:
my $array = ['Joe', 'Doe', 'Fo', 'Foo', 'FOO', 'Bar'];
e agora precisamos saber quantas vezes a palavra Foo aparece…
my $quantidade = scalar grep { /foo/i } @$array;
agora podemos usar o conteúdo
say $quantidade; # output: 2
Quem tiver mais dicas postem nos comentários… informações são sempre bem vindas! 
Bom pessoal, pretendo com esta série de artigos mostrar como criar uma aplicação usando tecnicas modernas de desenvolvimento em Perl fazendo uso do modulo MooseX::Declare.
Para isso resolvi que iria tramalhar com uma aplicação desktop e não com algo web. Usaremos para esta empreitada um modulo que nos permite criar telas de forma bem rápida e simples, o Tk (Toolkit).
Como não pretendo me prender a aspectos basicos da linguagem e tão pouco ao uso do módulo, imagino que o aspirante tenha conhecimentos em Perl (basicos~intermediarios) e que tenha uma boa base em desenvolvimento e estruturas de aplicações orientadas a objetos.
Obviamente espero que voce tenha o MooseX::Declare instalado em sua maquina. Caso não o tenha, siga os simples passos a seguir:
$ sudo perl -MCPAN -e "install MooseX::Declare"
Importante lembrar que este modulo depende do Moose e sendo assim este será instalado para que o MooseX::Declare possa ser usado.
Agora vamos instalar o Tk:
$ sudo perl -MCPAN -e "install Tk"
Simples? Apos tudo instalado podemos começar.
Abaixo vamos falar um pouco sobre a estrutura da aplicação. Pode não ser a melhor estrutura para fazermos uso mas é bem didática e isso garantirá um compreendimento por um maior numero de leitores.
+ – /calc
– calc.pl
+ – /App
+ /Form
– Base.pm
– Main.pm
A aplicacao sera inicializada pela classe calc.pl que executará o nosso formulario principal (Main.pm), que por sua vez herdará habilidades comuns para as classes de formulários implementadas na classe Base.pm
Vamos criar nosso arquivo chamado calc.pl que fará a chamada do nosso formulário principal.
#!/usr/bin/perl
use strict;
use warnings;
use App::Form::Main;
my $app = App::Form::Main->new;
$app->start;
=> Explicando:
Neste arquivo nos criamos uma instancia da classe que representa nosso formulário (tela) principal e invocamos o metodo C que faz com que a tela seja apresentada ao usuário.
Neste momento vamos criar uma classe que servirá de base para todos os outros FORMs. Esta classe terá metodos comuns que serão usados pelas telas do sistema.
use MooseX::Declare;
# start Tk base class
class App::Form::Base {
use Tk;
# Tk class attribute
has "window" => (
is => 'rw',
lazy => 1,
default => sub {
return MainWindow->new;
}
);
# method that config window widgets
method init {
die "Not implemented";
}
# method that start main window
method start {
$self->init;
return MainLoop;
}
}
=> Explicando:
Nesta classe nos temos uma implementação generica que disponibiliza um atributo que retorna uma instancia de uma janela.
O metodo C será utilizado para configurar os widgets (botoes, caixas de texto, menus, etc), e o C “executará” a criacao da janela propriamente dita.
Neste momento construiremos a nossa tela propriamente dita.
use MooseX::Declare;
# start Tk main window class
class App::Form::Main extends App::Form::Base {
# class attributes
has 'content' => ( is => 'rw' );
has 'display' => ( is => 'rw' );
has 'buttons01' => ( is => 'rw' );
has 'buttons02' => ( is => 'rw' );
has 'buttons03' => ( is => 'rw' );
has 'buttons04' => ( is => 'rw' );
has 'buttons05' => ( is => 'rw' );
has 'buttons06' => ( is => 'rw' );
has 'buttons07' => ( is => 'rw' );
has 'buttons08' => ( is => 'rw' );
has 'buttons09' => ( is => 'rw' );
has 'buttons00' => ( is => 'rw' );
has 'dot' => ( is => 'rw' );
has 'percent' => ( is => 'rw' );
has 'plus' => ( is => 'rw' );
has 'minus' => ( is => 'rw' );
has 'multiply' => ( is => 'rw' );
has 'divide' => ( is => 'rw' );
has 'c' => ( is => 'rw' );
has 'ce' => ( is => 'rw' );
has 'back' => ( is => 'rw' );
has 'equals' => ( is => 'rw' );
# method that start main window
override init {
my $menu = $self->window->Menu();
# config main window
$self->window->title('Modern Perl - Calculator');
$self->window->configure(
-menu=>$menu
);
# setting up menu
my $help = $menu->Menubutton(-text=>'Ajuda');
$help->command(-label=>'Sobre');
# calculator content
$self->content($self->window->Frame(
)->pack( -fill=>'both', -expand=>1, -ipadx=>135, -ipady=>145 )
);
# display screen
$self->display($self->content->Entry(
-text=>'',
-background=>'white',
)->place(
-y=>10,
-x=>10,
-height=>50,
-width=>250,
)
);
# clear button
$self->c($self->content->Button( -text=>'C', -command=> sub{ $self->clear_all }
)->place( -x=>216, -y=>75, -width=>42, -height=>42)
);
# ce button
$self->ce($self->content->Button( -text=>'CE', -command=> sub{ }
)->place( -x=>216, -y=>127, -width=>42, -height=>42)
);
# back button
$self->back($self->content->Button( -text=>' sub{ }
)->place( -x=>216, -y=>179, -width=>42, -height=>42)
);
# equals button
$self->equals($self->content->Button( -text=>'=', -command=> sub{ }
)->place( -x=>216, -y=>229, -width=>42, -height=>42)
);
# plus button
$self->plus($self->content->Button( -text=>'+', -command=> sub{ }
)->place( -x=>164, -y=>229, -width=>42, -height=>42)
);
# plus button
$self->plus($self->content->Button( -text=>'+', -command=> sub{ }
)->place( -x=>164, -y=>229, -width=>42, -height=>42)
);
# minus button
$self->minus($self->content->Button( -text=>'-', -command=> sub{ }
)->place( -x=>164, -y=>177, -width=>42, -height=>42)
);
# multiply button
$self->multiply($self->content->Button( -text=>'x', -command=> sub{ }
)->place( -x=>164, -y=>125, -width=>42, -height=>42)
);
# divide button
$self->divide($self->content->Button( -text=>'/', -command=> sub{ }
)->place( -x=>164, -y=>75, -width=>42, -height=>42)
);
# percent button
$self->percent($self->content->Button( -text=>'%', -command=> sub{ }
)->place( -x=>112, -y=>229, -width=>42, -height=>42)
);
$self->dot($self->content->Button( -text=>'.', -command=> sub{ $self->set_value( '.' ); }
)->place( -x=>62, -y=>229, -width=>42, -height=>42)
);
$self->buttons00($self->content->Button( -text=>'0', -command=> sub{ $self->set_value( 0 ); }
)->place( -x=>10, -y=>229, -width=>42, -height=>42)
);
$self->buttons01($self->content->Button( -text=>'1', -command=> sub{ $self->set_value( 1 ); }
)->place( -x=>10, -y=>177, -width=>42, -height=>42)
);
$self->buttons02($self->content->Button( -text=>'2', -command=> sub{ $self->set_value( 2 ); }
)->place( -x=>62, -y=>177, -width=>42, -height=>42)
);
$self->buttons03($self->content->Button( -text=>'3', -command=> sub{ $self->set_value( 3 ); }
)->place( -x=>112, -y=>177, -width=>42, -height=>42)
);
$self->buttons04($self->content->Button( -text=>'4', -command=> sub{ $self->set_value( 4 ); }
)->place( -x=>10, -y=>125, -width=>42, -height=>42)
);
$self->buttons05($self->content->Button( -text=>'5', -command=> sub{ $self->set_value( 5 ); }
)->place( -x=>62, -y=>125, -width=>42, -height=>42)
);
$self->buttons06($self->content->Button( -text=>'6', -command=> sub{ $self->set_value( 6 ); }
)->place( -x=>112, -y=>125, -width=>42, -height=>42)
);
$self->buttons07($self->content->Button( -text=>'7', -command=> sub{ $self->set_value( 7 ); }
)->place( -x=>10, -y=>75, -width=>42, -height=>42)
);
$self->buttons08($self->content->Button( -text=>'8', -command=> sub{ $self->set_value( 8 ); }
)->place( -x=>62, -y=>75, -width=>42, -height=>42)
);
$self->buttons09($self->content->Button( -text=>'9', -command=> sub{ $self->set_value( 9 ); }
)->place( -x=>112, -y=>75, -width=>42, -height=>42)
);
}
# Action that set method to Entry display
method set_value ( $value ){
$self->display->insert('end', $value);
# DEBUG: remove it
print "$value - ". $self->display->get() ."\n";
}
# Action that clear last number
method clear_last {
# TODO: get all display value, split by operators and remove last number
}
# Action that clear all display value
method clear_all {
$self->display->delete('0', 'end');
}
}
=> Explicando:
Esta classe cria a nossa tela, que e a de uma calculadora simples onde implementaremos a nossa solução.
O desenvolvimento da tela não existe segredo, nos só declaramo as propriedades da classe (uma para cada widget), contruimos e configuramos os widgets conforme a nossa necessidade.
Com este exemplo simples, podemos ver o quanto foi simples e rápido escrever uma app usando o MooseX::Declare. No próximo artigo, pretendo abordar a implementação das rotinas de calculo deste exemplo.
Pensamentos Retrógrados Que Acabam Com Uma Empresa
1 – “A TI da nossa empresa não é importante!”
Realmente, se você pensa dessa forma a sua empresa vai ter sérios
problemas num futuro próximo, quando você precisar fazer integrações
entre sistema ou de um sistema parrudo para ajudar na tomada de
decisões, automação de processo, etc…
2 – “Não vamos gastar dinheiro com este sistema! Nós mesmos podemos construir…”
Isso… assim vocês contratam Gerente de Projetos, Analistas, Arquitetos, Testadores e tudo mais que precise este pacote… Mas o melhor de tudo é você gastar tempo e dinheiro fazendo uma feramenta qua já existe e esta sendo largamente testada para dar mais segurança, estabilidade, etc…
Mas claro que você vai garantir tudo isso na sua aplicação, não é!?
Que tal comprar ou customizar uma? Vai ser mais rápido e vai gastar
menos dinheiro! 
3 – “Ahh eu clico aqui, copio ali colo e corto aqui e pronto, meu Excel faz a mesma coisa que esse sistema…”
Claro que faz… e você vai versionar a planilha cheia de macros e VBAs e depois de alguns meses vai ter vários monstrinhos na sua empresa.
Isso tudo sem contar a garantia de compatibilidade entre versões dos editores e tudo mais. Mas claro que você ja pensou nisso tudo!
4 – “Para que fazer uma aplicação para isso? Faz direto no banco!”
Hahahahaha essa é a pior!!!
O banco vai garantir o versionamento e claro que podemos usar paradigmas de programação dos mais atuais, testes automatizados, UML e documentação.
Faça um favor a você mesmo e diga pausadamente a palavra “BANCO DE DADOS”… Se não conseguir, tente novamente com um dicionário ao lado, você vai intender o verdadeiro uso desta solução.
5 – “Acesse o servidor XXY.ZZZ.W.YZZ e desenvolva aquela melhoria para liberarmos antes do almoço…”
Faça isso mesmo e vai ganhar um doce! =B
… e uma versão desatualizada de um sistema da próxima vez que publicar sua aplicação com aquela alteração que não estava no sistema de controle de versão! A propósito você usa ou sabe o que é um sistema de controle de versão?! Caso não, deveria pensar seriamente em usa-lo…. de forma CORRETA!
Bom acima temos um desabafo baseado em algumas da muitas situações lamentáveis a que já fui submetido e que eu realmente aconselho que as pessoas pensem muito bem antes de fazer!
Outras simplesmente são muito tristes e não teria forças para colocar aqui!
Trabalhar de forma correta, usando as soluções certas para resolver os problemas que estas se propõem é uma forma muito útil de garantir, economia de dinheiro, tempo e papel, pois você precisará ir menos no médico e consequentemente ele usará menos o bloco para lhe receitar remédios de pressão, enxaqueca e “anti-stress”!
Estes são meus centavos!
A algum tempo tenho estudado trabalhar na criação de uns hacks no sistema WebInject para utilizar na empresa Bivee afim de simplificar a execução dos testes em aplicações web pelo time de testes.
Entre algumas melhorias que serão desenvolvidas estão melhorias na interface, trabalho forte na documentação do projeto, modulo web e outros. Abaixo segue a lista estimada para a a primeira versão do projeto após o hackathon:
- Melhorias na interface gráfica do projeto
- Melhorias nos manuais e documentações
- Aplicação de Modern Perl Coding style
- Uso de banco de dados e logs
- Módulo web para publicação e consulta
- Versionamento dos casos de teste
- Modo teste de regressão
- Módulo de relatórios
Bom, esperamos que esta seja algumas das melhorias conseguidas logo após o primeiro hackathon para que possamos reportar os hack na ferramenta aos criadores originais fazendo assim crescer o uso a ferramenta e a força da comunidade também.
Sei que este tema ja foi largamente discutido na comunidade e que temos várias formas de fazer isso com módulo e tudo mais… mas a intenção deste post realmente não é dar uma bala de prata para a resolução do problema.
Vamos a explicação:
PROBLEMA: Temos um código que é propicio a “exceções” e gostaríamos de fazer uma tratativa para verificar quando estes códigos “morrem”.
package FileOp;
sub new {
return bless {}, shift || ref shift;
}
sub open_file {
my $self = shift;
open my $file, shift or die $!;
...
close $file;
}
package main;
my $file = FileOp->new;
my $foo = $file->open_file( './file.txt' ); # die "arquivo não existe"
PROPOSTA: Uso do eval {}
use Carp;
my $file = FileOp->new;
eval {
my $foo = $file->open_file( './file.txt' ); # die "arquivo não existe"
...
};
if ( $@ ) {
say "O sistema foi encerrado porque: ". $!;
}
Isso é uma solução simples e primária para o problema, porem no CPAN existem inúmeros módulos que tratam fluxo de erros, exceptions, etc..
Abaixo eu sito alguns:
Carp –
http://search.cpan.org/~jesse/perl-5.14.1/lib/Carp.pm
Try::Tiny –
http://search.cpan.org/~doy/Try-Tiny-0.09/lib/Try/Tiny.pm
TryCatch –
http://search.cpan.org/~ash/TryCatch-1.003000/lib/TryCatch.pm
Throwable –
http://search.cpan.org/~rjbs/Throwable-0.102080/lib/Throwable.pm
… e muitos outros! ; )
Fica a dica, tratem os fluxos de erros do seu sistema, pois isso é tão [importante quanto|faz parte] o desenvolvimento das funcionalidades do seu sistema.
Este post é bem rápido e tem com objetivo mostrar o funcionamento do modulo MooseX::Declare e o efeito dele na sintaxe do código. Apesar de ser um exemplo bem simples o intuito aqui não é esgotar o assunto mas sim prover uma certa curiosidade sobre o uso deste módulo.
Para saber mais noticias sobre este módulo veja o doc em
http://search.cpan.org/~flora/MooseX-Declare-0.34/lib/MooseX/Declare.pm
Sem mais delongas, vamos ao exemplo e as notas sobre o mesmo:
No exemplo acima, podemos perceber que a sintaxe na declaração da classe foi completamente “alterada”.
Na declaração da classe tivemos mudanças radicais…
package People; => class People { … }
Se olharmos bem a declaração dos atributos da classe neste exemplo vamos perceber que não mudaram muito do modo como os declarávamos usando o Moose, mas este por outro lado revolucionou e simplificou e muito a forma tradicional de se criar classes, roles e declarar atributos.
use MooseX::Declare;
class People {
# class attribute
has 'name' => ( isa => 'Str', is => 'rw' );
# method declaration
method meet_you() {
say "Prazer em conhecer você, ".
$self->name if defined $self->name;
}
}
Nos métodos também podemos ver uma mudança sutil, não vemos a linha abaixo da declaração do método as inscrições “my $self = shift;” que mesmo no Moose tradicionalmente usávamos para receber a referencia para a objeto instanciado. Esta inscrição agora implícita, simplifica ainda mais a forma com que vemos nossos métodos.
Como vimos no exemplo acima, em Perl nós temos mais de uma maneira de se fazer algo e isso vem ficando cada vez mais evidente. O modulo MooseX::Declare nos traz algumas features muito interessantes e que simplificam ainda mais a forma como lemos e escrevemos nosso código.
Então deem uma olhada no doc que contem melhores exemplos e explicações, faça seus testes e brinque um pouco com o módulo que é bem interessante.
Bom, não sou de postar essas coisas mas tem muita gente que esta começando e gostaria de ter o gostinho de colocar um web site no ar, mas ainda sim tem receio de pagar uns $ 5 mangos para isso rs.
Eu em meados de 2005 procurei um serviço de hospedagem grátis para me ajudar a publicar uns trabalhos de uns clientes para validação e para colocar uns projetos em teste online e conheci o Awardspece.com.
Uso o serviço até hoje e gosto da qualidade do serviço (mesmo que gratis), o pessoal mostra um comprometimento bacana no forum para tentar ajudar os usuários.
Com 250MB da espaço, uso de ftp, suporte a linguagens como Perl e PHP, banco de dados MySQL e não obriga uso de Ads, torna-se uma excelente opção para fazer pequenos trabalhos e para quem esta começando a desenvolver sistemas para web e gostaria de estars
Não estou ganhando nada para indicar mas achei que valeria a dica pra que possa interessa…
Awardspace: http://www.awardspace.com
Um dia estava em me trabalho e um amigo iniciou uma conversa sobre a distribuição linux que ambos gostamos muito de utilizar que é o Damn Small Linux. Então no contexto da conversa ele me dizia estar querendo facilitar o acesso aos dados do sistema, instalando um FM (File Manager) melhor e mais intuitivo, já que o Gerenciador de Arquivos padrao (EmelFM) é pouco intuitivo apesar de eu gostar muito dele.
Pensando nisso e enquanto conversava com ele abri o meu VIM e começei a brincar com os códigos e o módulo Tk… e o resultado pode ser visto na screenshot abaixo!
Claro que não existe nem um callback mais complexo implementado (o horário de almoço tinha acabado e estava no Windows…) mas em fim, foi uma experiencia interessante para fins didáticos.
Este é um projeto que visa desenvolver uma plataforma simples de desenvolvimento gráfico baseando-se na interface gráfica Tk (ToolKit).
Perl Tk Development IDE
O layout do IDE foi inspirado no Glade para que ficasse mais simples a adaptação e uso por desenvolvedores acostumados com o mesmo.
O sistema ainda esta em fase de desenvolvimento mas promete ser uma excelente alternativa já que as IDEs para desenvolvimento gráfico em Perl/Tk são tão pouco intuitivas e o desenvolvimento das telas lento e maçante.
Forte abraço a todos.
Projeto de desenvolvimento de ferramentas afim de facilitar a vida do usuário deste excelente sistema linux minimalista de apenas 50MB.
O projeto Damn Small Linux Brasil visa desenvolver as ferramentas para este sistema de forma que as mesma façam uso mínimo da memória seguindo assim a filosofia da distribuição porem sem perder a beleza e provendo facilidades na administração e configuração do sistema ao usuário.
Imagem de ferramentas desenvolvidas
(DSL Panel e MyDSL Browser)
O projeto esta em fase de desenvolvimento e levantamento dos requisitos e arquitetura e a implementação será feita em C++ utilizando o Tool Kit gráfico FLTK que alem de ser muito bem acabado e pequeno é muito poderoso e fornece uma infinidade de widgets uteis ao propósito do projeto.
“Aos desenvolvedores que estiverem e/ou puderem ajudar no projeto serão sempre muito bem vindos.”
Alguns links referentes ao projeto:
| Nome | Endereço (url) |
| Site Official do Projeto | http://www.damnsmalllinux.org |
| Google Group Brasileiro | http://groups.google.com.br/group/damn-small-linux-brasil |
| Google Code | http://code.google.com/p/dsl-brasil/ |
Qualquer duvida sobre o projeto deixo-me a disposição para responder.
Forte abraço a todos,
