DEV Community: Victoria Ricarte Bispo Beserra

Orientação a Objeto com Corinna (Perl)

Victoria Ricarte Bispo Beserra — Fri, 24 Jan 2025 19:18:56 +0000

E ai galera? Depois de 3 anos offline por aqui estou de volta!🤗
Meu último post foi voltado para mudanças por aqui, eu tinha começado a programar em JavaScript utilizando TypeScript (NodeJS), um grande desafio. Tinha prometido ~~postar sobre essa trajetória~~, 😅 mas fiquei atarefada demais no novo trabalho. 🚨 KKKKRY
Agora, voltando para as origens com Perl, vou voltar a fazer publicações pontuais sobre o que aprendi de novo na linguagem e com o que estarei trabalhando por aqui. Vamos passear entre o Perl e o NodeJS durante o ano? 👩🏻‍💻

E para o come back vamos explorar Corinna

⚠️ATENÇÃO
Este post não tem como objetivo definir orientação a objeto nem sintaxes básicas do perl, por tanto ele leva em consideração que você, leitor, tenha conhecimento básico de perl e saiba orientação a objeto e suas definições.

A partir da versão 5.36 do Perl a linguagem ganhou suporte a um sistema de orientação a objetos que é fruto de anos de colaboração entre a equipe do Corinna e a comunidade Perl. Onde seu maior objetivo é simplificar a orientação a objetos utilizando o Perl.

A gente consegue resumir o Corinna em quatro palavras chaves que vamos utilizar dentro do nosso código fonte:

class: Para declarar uma classe;
field: Para declarar um atributo (campo);
method: Para declarar um método;
role: Para declarar uma função;

Aplicação

O primeiro passo é garantir que a versão do Perl que estamos utilizando. Como disse anteriormente precisamos de uma versão a cima da 5.36. Em seguida adicione no seu script use experimental 'class'; para ativar o experimental Corinna.
E para começar a implementação de maneira simples vamos declarar a nossa primeira classe:

use v5.36;
use experimental 'class';

class Usuario {

...

}

E para criar uma instância do objeto basta utilizar a seguinte sintaxe:

my $produto = Produto->new();

Passando dentro dos parênteses os atributos que vamos ter declarados dentro da nossa classe.
Na sequência temos a declaração dos atributos, de maneira também muito simples utilizando a palavra chave field:

use v5.36;
use experimental 'class';

class Usuario {

    field $nome;
    field $email;

}

Além de declarar os nossos atributos vamos precisar adicionar modificadores. Quando definimos apenas com o field ele é criado como uma propriedade privada da nossa classe e para serem acessados e/ou modificados de maneira mais simples podemos utilizar esses modificadores para personalizar seus comportamentos:

:reader : Para gerar automaticamente um método de leitura;
:writer : Para gerar automaticamente um método de escrita;
:param : Para inicializar o atributo diretamente no construtor;
:default : Para definir um valor padrão;
:lazy : Utilizado com default, faz com que o valor padrão seja calculado apenas na primeira vez que o atributo é acessado;
:builder : Para definir um método que será chamado para inicializar ele;

A seguir vou mostrar como podemos utilizar cada modificador:

use v5.36;
use experimental 'class';

class Usuario {

    field $nome :reader :param;
    field $email :reader :writer :param;
    field $status :reader :default('ativo');
    field $criado_em :reader :lazy :default(sub { time });

}

# Testando
my $usuario = Usuario->new(nome => 'Victoria', email => 'victoria@example.com');
say $usuario;

# Atualizando o email
$usuario->$email('nova@example.com');
say "\nEmail atualizado: ", $usuario->$email;

Para executarmos o nosso script lembre sempre de salvar com uma extensão .pl como por exemplo main.pl e execute utilizando o seguinte comando no terminal:

perl main.pl

Para implementar um novo método, basta declarar utilizando a palavra mothod e para utilizar basta chamar utilizamos ->methodName() na classe que instanciamos:

class Usuario {

    field $nome :reader :param;
    field $email :reader :writer :param;
    field $status :reader :default('ativo');
    field $criado_em :reader :lazy :default(sub { time });

    # Método
    method exibir_detalhes {
        say "Nome: ", $self->$nome;
        say "Email: ", $self->$email;
        say "Status: ", $self->$status;
        say "Criado em: ", scalar localtime($self->$criado_em);
    }

}


# Testando
my $usuario = Usuario->new(nome => 'Victoria', email => 'victoria@example.com');
$usuario->exibir_detalhes();

Existem comportamentos e atributos que precisamos compartilhar entre classes, mas essas classes não estão relacionadas diretamente por herança. Para não repetirmos código, evitar problemas de herança múltipla e separar corretamente as responsabilidades podemos utilizar role. Por exemplo, um comportamento como "validar dados" ou "logar ações" pode ser usado por diferentes classes. Para utilizar uma role basta utilizarmos does após o nome da classe, e é possível utilizarmos mais de uma role nas classes como veremos aqui embaixo:

use v5.36;
use experimental 'class';


role Loggable {
    method log($message) {
        say "[LOG]: $message";
    }
}

role Validacoes {
    method validarEmail($email) {
        die "Email inválido\n" unless $email =~ /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
        return $email;
    }
    method validarPreco($preco) {
        die "Preço inválido: deve ser positivo\n" if $preco < 0;
        return $preco;
    }
}

class Usuario does Loggable does Validacoes {

    field $nome :reader :param;
    field $email :reader :writer :param;
    field $senha :reader :writer :param;
    field $status :reader :default('ativo');
    field $criado_em :reader :lazy :default(sub { time });

    method logarUsuario($email, $senha) {
        $self->validarEmail($email))  # Usa o método do role
        $self->log("Pessoa logado com Sucesso!"); # Usa o método do role

    }

}

class Produto does Loggable does Validacoes {

    field $nome :reader :writer :param;
    field $descricao :reader :writer :param;
    field $preco :reader :writer :param;


    method cadastrarProduto($nome, $descricao, $preco) {
        $self->validarPreco($preco);  # Usa o método do role
        $self->log("Produto cadastrado com Sucesso!"); # Usa o método do role
    }

}

# Testando
my $usuario = Usuario->new(nome => 'Victoria', email => 'victoria@example.com','123456');
$usuario->logarUsuario('victoria@example.com','123456');

my $produto = Produto->new(nome => 'Caderno', descricao => '200 folhas e 5 matérias', preco => 30.50);
$produto->cadastrarProduto('Caderno','200 folhas e 5 matérias', 30.50);

Hoje a gente fica por aqui

Aprendemos como usar as quatro palavras chaves do Corinna para a POO com Perl, e em breve vou trazer para vocês novas implementações com mais complexidade e soluções incríveis. Até a próxima.

Fontes:
Repositório do Corinna no GitHub: Este repositório centraliza discussões e propostas para integrar um sistema OO moderno ao núcleo do Perl.

GITHUB

Corinna no Perl Core: Artigo que discute a integração do Corinna ao núcleo do Perl, destacando suas vantagens e implicações.

OVID'S PROGRAMMING, POLITICS, AND PROSE

Corinna "Quickstart" Tutorial: Um tutorial introdutório que oferece uma visão geral prática do uso do Corinna para programação OO em Perl.
GITHUB

Mudanças por aqui…

Victoria Ricarte Bispo Beserra — Sun, 29 May 2022 17:32:26 +0000

Muito se vê na internet sobre como entrar no mundo da T.I., mudar de carreira, migrar de área, aprender uma tecnologia do zero ao avançado. Mas, particularmente, não encontrei por acaso nenhuma publicação sobre mudanças dentro da própria carreira como por exemplo: Migrar de tecnologia, que é uma realidade muito comum dentro da nossa área. Eu, por exemplo, sou programadora a 4 anos. E no meio dessa jornada tive que migrar de linguagem de programação 3 vezes.

Comecei minha carreira logo após terminar a faculdade de Sistemas de Informação em uma empresa pequena. Lá aprendi do zero uma linguagem de programação que não conhecia na época da faculdade, o Delphi. Trabalhei com Delphi em um CRM com código legado por dois anos, cuidado dos processos desde a coleta de requisitos, passando pela modelagem e banco de dados até a programação e testes da aplicação. Foi uma experiência enriquecedora, entretanto para crescer na carreira tive que mudar de emprego.

Quando entrei na minha nova empresa fui trabalhar com Perl também em um sistema legado, me vi mais uma vez tendo que aprender algo do zero. Logo passei a gostar bastante do Perl, e ele me impulsionou a começar a publicar aqui.

Hoje, me encontro novamente em posição de mudanças. Iniciando meus estudos com NodeJS para, com uma equipe bem estruturada, reescrever o sistema de um cliente.

Claro que para um profissional da área da T.I é sempre mais simples assimilar novas tecnologias dado que já se tem uma boa base de lógica de programação e algoritmos. Mas cada pessoa tem uma metodologia e tempo diferentes para aprender e aperfeiçoar as suas skills.

No decorrer dos meus estudos estarei publicando aqui os caminhos que vou seguir para aprender essa nova tecnologia. Vamos embarcar nessa comigo?

Mojolicious

Victoria Ricarte Bispo Beserra — Mon, 16 May 2022 22:45:44 +0000

Durante um ano e meio trabalhei com o mojolicious em um projeto legado dentro de uma empresa de telecomunicações. Aprendi a fazer diversas coisas com ele e hoje vim contar para vocês como ele funciona.

O que é?

O mojolicious é um framework composto de um conjunto de componentes para desenvolvimento Web em tempo real com Perl usando um MVC bem estruturado. Abaixo podemos observar alguns dos seus recursos disponíveis:

Implementação cliente/servidor HTTP e WebSocket com IPv6, TLS, SNI, IDNA, proxy HTTP/SOCKS5, socket de domínio UNIX, Comet (long polling), Promises/A+, async/await, keep-alive, timeout, suporte a compressão cookie, multipart e gzip.
Servidor da Web de E/S sem bloqueio integrado, com suporte a vários loops de eventos, bem como pré-bifurcação opcional, perfeito para criar serviços da Web altamente escaláveis.
Analisador JSON e HTML/XML com suporte a seletores CSS.

Como usar?

Perlbrew

Recomendo que como primeiro passo para programar em Perl baixem o gerenciador de instalação Perlbrew. Ele vai te ajuda-los a ter várias versões do perl instaladas no seu computador e te auxiliar a administra-las de maneira bem simples.

Para instalar o Perlbrew basta executar o seguinte comando no terminal:

$ curl -L https://install.perlbrew.pl | bash

Para instalar a versão estável mais recente e usá-la a partir de agora:

$ perlbrew install perl-5.34.0
$ perlbrew switch perl-5.34.0

Para programar com a versão mais atualizada, mas apenas no terminal atual:

$ perlbrew install perl-blead
$ perlbrew use perl-blead

Para executar meuprograma.pl em todas as instalações do perl, muito útil ao fazer testes:

$ perlbrew exec perl meuprograma.pl

Para a folha de dicas de uso básico:

$ perlbrew -h

Para mais descrições sobre comandos:

$ perlbrew help

Instalação

A instalação do mojolicious pode ser feita de maneira rápida no terminal por meio de apenas uma linha:

$ curl -L https://cpanmin.us | perl - -M https://cpan.metacpan.org -n Mojolicious

Hello Word!

Como prometido, abaixo mostro a vocês como é simples escrever uma aplicação Web completa com o mojolicious utilizando apenas as linhas a seguir:

#!/usr/bin/env perl
use Mojolicious::Lite;

get '/' => {text => 'Hello Word!'};

app->start;

Basta salvar o arquivo com a extensão .pl e executa-lo usando morbo para inicia-lo com servidor web integrado.

$ morbo hello.pl
Web application available at http://127.0.0.1:3000

$ curl http://127.0.0.1:3000/
Hello Word!

👋🏻 Então pessoal, como viram a cima usar o mojolícious não é tão difícil, e como disse no começo ele pode nos ajudar em diversas coisas. Nos próximos posts irei ensinar a vocês todos os principais recursos desse framework e as classes que o compõem. fiquem ligados para os próximos posts. Até a próxima.

Moo - Orientação de objeto minimalista

Victoria Ricarte Bispo Beserra — Tue, 26 Apr 2022 15:55:16 +0000

Como começar a programar em Perl da maneira correta. ~~(Diferente de mim)~~

Perl Orientado a Objeto Part I

Perl Orientado a Objeto Part II

Perl Orientado a Objeto Part III

Moo - Orientação de objeto minimalista

O que é o Moo

Diferente do Moose, que vimos anteriormente, o Moo é um sistema de orientação a objetos extremamente leve. Permitindo definições de objetos e funções de maneira bem simples. Tem um sub-conjunto do Moose o Moo evita depender de qualquer módulo XS para permitir implantações simples. Fornece quase dois terços do Moose.

Quando usar o Moo

Como dito a cima, o Moo deve ser utilizado quando a aplicação preza por rapidez ao carregar pacotes e não tem necessidade de utilização de todos os metaprotocolos do Moose. A seguir exemplifico alguns casos que o podemos escolher o Moo:

Quando uma linha de comando ou script CGI onde a inicialização rápida é essencial;
Código projetado para ser implantado como um único arquivo via App::FatPacker;
Um módulo CPAN que pode ser usado por outros nas situações acima;

Incompatibilidades do Moo para o Moose

Se o Moo detectar que o Moose está sendo carregado, ele registrará automaticamente metaclasses para seus pacotes Moo , então você poderá usá-los no código do Moose sem modificação.

O Moo não dará suporte para initializer, super, override, inner e augment pelos seus criadores considerarem más idéias ou práticas de programação no Perl.

Usando o Moo nos exemplos dos artigos anteriores

package Performances;
use strict;
use warnings;
use Moo;

# Declare the attributes
has 'name' => (is  => 'rw', # Declare read and write at runtime
    default =>'No name', # Attribute default value
);

has 'audience' => (isa =>'Int', # Declare as integer
  is => 'rw',
  default => sub { 
      my $self = shift; 
      my $qtd = shift;
      return $qtd if defined $qtd and $qtd > 0;
      return 'No audience or invalid value';
  } # Attribute default value
); # Declare read and write at runtime

Sub-rotinas importadas

Extends

Declara uma classe base. A classe será carregada, mas nenhum erro será acionado se a classe não puder ser encontrada e já houver subs na classe.

Chamar extends mais de uma vez irá SUBSTITUIR suas superclasses, não adicionar a elas como 'use base' ou ‘use parent’ faria.

extends 'Performances';

With

with 'Performances::Tragedy', 'Performances::Comedy';

Indica que a classe atual compõe uma ou mais funções da Performances . Um erro será gerado se essas funções não puderem ser compostas porque possuem definições de método conflitantes. As funções serão carregadas usando o mesmo mecanismo que os extends.

Has

Declara um atributo para a Classe.

Obrigatório para a declaração , pode ser ro, lazy, rwp ou rw.

ro - significa "somente leitura" e gera um acessador que morre se você tentar escrever nele - ou seja, apenas um getter - padronizando reader o nome do atributo.
lazy - gera um leitor como ro, mas também define lazy como 1 e builder como build${attribute_name} permitir atributos gerados sob demanda.
rwp -significa "ler-escrever protegido" e gera um leitor como ro, mas também define writer para set${attribute_name} atributos que são projetados para serem escritos de dentro da classe, mas somente leitura de fora.
rw - significa "ler-escrever" e gera um getter/setter normal padronizando o accessor o nome do atributo especificado.

isa

Recebe um coderef que é usado para validar o atributo. Ao contrário do Moose, o Moo não inclui um sistema de tipo básico, então ao invés de fazer isa ⇒ ‘str’, deve-se fazer:

package Performances;
...
# Declare the attributes
has 'name' => (is  => 'rw', # Declare read and write at runtime
    default =>'No name',
    isa => sub {
            die "$_[0] is not a name!" unless looks_like_name $_[0]
        } # Attribute type
);

coerce

Recebe um coderef que se destina a coagir o atributo. A ideia básica é fazer algo como o seguinte:

package Performances;
...
# Declare the attributes
has 'audience' => (
    isa => sub {
        die "$_[0] is not a number!" unless looks_like_number $_[0]
        },
    coerce => sub {
            $_[0] % 2 ? $_[0] : $_[0] + 1
        } # Attribute type for audience always ever 
);

Observe que o Moo sempre executará sua coerção: isso é para permitir que as entradas de isa sejam usadas puramente para captura de bugs, enquanto as coerções são sempre estruturais para seu código. No entanto, aplicamos a verificação de isa após a execução da coerção para garantir que ela retornou um valor válido.

trigger

Recebe um coderef que será chamado sempre que o atributo for definido. Isso inclui o construtor, mas não os valores padrão ou construídos. O coderef será invocado no objeto com o novo valor como argumento.

default

Recebe um coderef que será chamado com $self como seu único argumento para preencher um atributo se nenhum valor para esse atributo for fornecido ao construtor. Como alternativa, se o atributo for lazy, será default executado quando o atributo for recuperado pela primeira vez se nenhum valor ainda tiver sido fornecido.

predicate

Recebe um nome de método que retornará true se um atributo tiver um valor. Se você definir como apenas 1, o predicate será nomeado automaticamente has_${attr_name} se o nome do seu atributo não começar com um sublinhado ou has_${attr_name_without_underscore} se começar.

clear

Recebe um nome de método que limpará o atributo. Se você definir como apenas 1, o clear será nomeado automaticamente clear_${attr_name} se o nome do seu atributo não começar com um sublinhado ou clear${attr_name_without_the_underscore} se começar.
NOTA: Se o atributo for laze, ele será gerado novamente default ou buider na próxima vez que for acessado. Se não for, será undef.

lazy

Recebe um booleano. Definir se desejar que os valores do atributo sejam capturados lentamente. Isso geralmente é uma boa ideia se você tiver um "construtor" que requer que outro atributo seja definido.

required

Recebe um booleano . Definir se o atributo deve ser passado na instanciação do objeto.

reader

O valor deste atributo será p nome do método que retorna o valor do atributo.

writer

O valor deste atributo será o nome do método para definir o valor do atributo.

weak_ref

Recebe um booleano . Definir se desejar que a referência que o atributo contém seja enfraquecida. Use isso quando referências circulares, que causam vazamentos de memória, são possíveis.

init_arg

Recebe o nome da chave a ser procurada no momento da instanciação do objeto. Um uso comum disso é fazer com que um atributo sublinhado tenha um nome de inicialização não sublinhado. undef significa que passar o valor na instanciação é ignorado.

moosify

Recebe um coderef ou uma matriz de coderefs que se destina a transformar as especificações de atributos fornecidas, se necessário, ao atualizar para uma função ou classe Moose. Você não deve precisar disso por padrão, mas é fornecido como um meio de extensibilidade possível.

before, around e after

before chamado antes do método que está modificando.

around chamado em vez do método que está modificando. O método que você está substituindo é passado como o primeiro argumento (chamado $orig por convenção). Cuidado com os valores de retorno contextuais de $orig.

after é chamado após o método que está modificando.

👋🏻 Então pessoal, hoje definimos o Moo, mostramos onde ele pode ser usado e quais suas incompatibilidades com o Moose. Qualquer dúvida, ou sugestão para os próximos artigos, podem deixar nos comentários. Até a próxima.

Perl Orientado a Objeto Part III

Victoria Ricarte Bispo Beserra — Sun, 24 Apr 2022 13:50:54 +0000

Perl Orientado a Objeto Part I

Perl Orientado a Objeto Part II

Perl Orientado a Objeto Part III

Moo - Orientação de objeto minimalista

Moose: Um jeito mais elegante de usar a Orientação a Objeto no Perl

O Moose fornece um conjunto de funções exportadas que torna o Perl Orientado a Objeto com uma sintaxe que funciona de maneira muito mais simples e bonita. Permitindo que voltemos nossa atenção para a abstração de dados, no lugar de focar nos detalhes de implementação.

⚠️ Este post tem como objetivo implementar orientação a objeto com Perl utilizando o Moose, por tanto ele leva em consideração que você, leitor, tenha conhecimento de lógica e linguagem e programação, saiba algumas definições de orientação a objeto e conheça a sintaxe básica do Perl.

Construtor e atributos com Moose

Seguindo a linha de raciocínio dos exemplos dos artigos passados, agora vamos implementar a classe Performances utilizando o Moose a seguir:

package Performances;

use Moose;

# Declare the attributes
has 'name' => (is  => 'rw', # Declare read and write at runtime
    required => 1, # make the required attribute, value = 0 optional
    default =>'No name', # Attribute default value
);

has 'audience' => (isa =>'Int', # Declare as integer
  is => 'rw',
    required => 1, 
    default => sub { 
        my $self = shift; 
        my $qtd = shift;
        return $qtd if defined $qtd and $qtd > 0;
        return 'No audience or invalid value';
    } # Attribute default value
); # Declare read and write at runtime

package Calculation

use lib ".";
use Performances;

# Calling the constructor and assigning value to attributes
my $performace = Performances->new(audience=>55, name=>"hamlet");

# Introducing the attributes
printf "The play presented was %s  and its audience was %d people\n ",
$performace->name, $performace->audience;

Como podemos observar, ao usarmos o Moose e definirmos os atributos audience e name, o Moose faz a criação internamente, tanto do seu construtor, quanto métodos para atribuir valor aos seus atributos e métodos de leitura.

Para implementar relacionamentos no Perl vamos refatorar nossa classe de Tragedy. Abaixo, podemos observar a partir do código que Tragedy tem uma Performance do tipo específico de Tragedy.

package model::Performances::Tragedy; # Child Class
use Moose;
use lib (".");
use Performances; # Parent Class

use constant # Creating constants for play types
    TYPE_PLAY => {
        "tragedy" => 40,
        "comedy" => 60
    };

has 'performance' => {
    isa => "Performances", # Using @ISA with Moose
    is => "rw",
    default=> sub {
        return Performances->new(type_play => TYPE_PLAY->{tragedy});
    },
    required => 1
};

O Moose é uma ferramenta muito potente e além do básico que aprendemos aqui no https://metacpan.org/ você pode encontrar toda a sua documentação.
Como nem tudo são flores o Moose também tem seus defeitos. Por ser tão potente ele por sí só já é enorme, e por isso pode deixar aplicações simples lentas. Ele gera muito código por trás da sua implementação para facilitar sua programação, então você pode pagar com processamento quando os módulos são carregados pela primeira vez.

Moo: Um subconjunto do Moose

o Moo chegou para pesar menos no seu processamento. Ele implementa um subconjunto de funcionalidades do Moose em um pacote mais simples. Sem implementar toda a API de introspecção do Moose sem perder a interoperabilidade com o Moose.

Caso você use o pacote de introspecção enquanto está usando o Moo, ele infla de maneira transparente o API do Moose dentro da suba classes ou função. Isso torna mais fácil incorporar Moo usando código em uma Moose base de código e vice-versa.

👋🏻 Então pessoal, essa foi a implementação básica do Moose, recomendo que olhem as demais aplicações na sua documentação. A seguir falaremos sobre o MOO. Até a próxima.

Perl Orientado a Objeto Part II

Victoria Ricarte Bispo Beserra — Sat, 23 Apr 2022 13:09:49 +0000

Como começar a programar em Perl da maneira correta. ~~(Diferente de mim)~~

Perl Orientado a Objeto Part I

Perl Orientado a Objeto Part II

Perl Orientado a Objeto Part III

Moo - Orientação de objeto minimalista

Os 4 pilares da Programação Orientada a Objetos

Abstração, encapsulamento, herança e polimorfismo são os quatro pilares de qualquer linguagem orientada a objetos. E como aprendemos no post passado o Perl é uma linguagem que da suporte a orientação a objeto a partir da sua versão 5. A seguir vou dar exemplos a vocês de como podemos implementar esses pilares.

⚠️ Este post não tem como objetivo definir orientação a objeto com Perl, mas sim aprofundar conhecimentos prévios que você tenha baseando-se na linguagem. por tanto ele leva em consideração que você, leitor, tenha conhecimento de lógica e linguagem e programação e saiba algumas definições de orientação a objeto.

Abstração

O primeiro pilar fala sobre como vamos representar os objetos dentro no nosso programa, é o que Moose é uma extensão do sistema de objetos da linguagem de programação Perl . Seu propósito declarado [1] é trazer recursos modernos de linguagem orientada a objetos para o Perl 5 e tornar a programação Perl orientada a objetos mais consistente e menos tediosa.vai também facilitar a leitura do nosso código por terceiro. É importante ter clareza ao dar nome a nossas Classes, Atributos e Métodos.

Encapsulamento

O encapsulamento trata da segurança das partes do seu programa. Quem implementa suas classes com seus atributos e usa seus métodos não precisa saber de tudo que se passa dentro da sua construção a não ser o que está na sua API.

Polimorfismo

O polimorfismo é referente a capacidade que a linguagem tem de identificar e diferenciar entidades, métodos ou atributos com mesmo nome de maneira eficiente.

A seguir irei mostrar os principais polimorfismos em Perl:

Substituição

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

package controller::Calculation;

use model::Performances;

# We declare entity and assign the value of tragedy with its attributes
my $entity = model::Performances::Tragedy->new('othelo',55); 
# Then we replace entity with the value returned from one of its methods
my $entity = $entity->amount_for();

Sobrecarga

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

package model::Performances::Tragedy; # Child Class

use parent 'Performances';  # Parent Class 

sub new { # writing over the Performances builder
    my $this = shift;
    my $class = ref ($this) || $this;
    my $name = shift;
    my $audience = shift;

    my $self = new Performances($name,$audience,TYPE_PLAY->{tragedy});

    return bless $self, $class;

}

Inclusão

Que é o tipo de polimorfismo de herança que veremos a seguir.

Herança

E é aqui onde o POO ganha meu coração🥰
É com a herança que podemos aplicar a abstração e o encapsulamento para melhorar nossos códigos.

Evitando repetições “herdando” métodos semelhantes ou re-escrevendo os mesmos;
Utilizando os mesmos atributos para diferentes classes (não tão diferentes assim) para evitar classes de linhas quilométricas;

A herança no Perl pode ser implementada com o uso de pacotes no seu código, que como aprendemos anteriormente, os pacotes serão as classes. Cada pacote em perl tem um array especial chamado @isa que guarda toda a hierarquia de classes pai daquela classe. Veja o código a seguir, continuando a linha de raciocínio anterior:

#!/usr/bin/perl
use strict; # Error readability
use warnings;
use constant # Creating constants for play types
    TYPE_PLAY => {
        "tragedy" => 40,
    };

package model::Performances::Tragedy; # Child Class
@Performances::Tragedy::ISA = ('Performances'); # Parent Class

A atribuição feita na linha “@Performances::Tragedy::ISA = ('Performances');” indica que a classe Tragedy é uma filha da classe Perfomances, por tanto herda todos seus atributos e sub-rotinas.

Entretanto não existe a necessidade de atribuirmos diretamente ao array @isa todas as heranças de nossas classes, dado que em um sistema mais complexo que possa envolver enrança múltipla ou que a arvore de herança fique muito grande, possamos encontrar dificuldades. Mas ainda podemos encontrar essas atribuições em códigos antigos.

Além de atribuir diretamente ao @isa, podemos encontrar o uso de base para indicar herança dentro do Perl. Porém esse uso não é mais aconselhado a partir do momento que foi criado o parent, que é uma versão do base mais limpa. A seguir podemos observar um exemplo de como usar o parent na classe Comedy:

#!/usr/bin/perl
use strict; # Error readability
use warnings;
use constant # Creating constants for play types
    TYPE_PLAY => {
        "tragedy" => 40,
        "comedy" => 60
    };
package model::Performances::Comedy; # Class
use parent 'Performances';    # sets @Performances::Comedy::ISA = ('Performances');

Principais características de base e parent:

O base faz as seguintes coisas:

Adiciona o pacote nomeado a @isa;
Carrega o módulo com o mesmo nome do pacote nomeado usando require (a menos que detecte que o pacote já foi carregado);
Não falhará se um módulo com o mesmo nome do pacote não existir;
Morre se não houver símbolos no pacote nomeado;
Inicializa o [fields]http://perldoc.perl.org/fields.html) do pacote nomeado se eles existirem;

O parent faz as seguintes coisas:

Adiciona o pacote nomeado a @isa;
carrega o módulo com o mesmo nome do pacote nomeado usando require (a menos que detecte que o pacote já foi carregado)
Não chama a função de importação do pacote nomeado;
A opção norequire diz para não fazer o require (então a classe já deve estar carregada). Isso significa que ele não precisa interceptar erros e decidir se eles devem ser suprimidos ou não.

👋🏻 Então pessoal, esses foram os pilares da Programação Orientada a Objetos no perl. Continuem de olho que logo mais farei publicações sobre o Moose e o Moo, suas diferenças e outras aplicações voltadas a essa linguagem de programação tão abrangente. Até a próxima.

Perl Orientado a Objeto Part I

Victoria Ricarte Bispo Beserra — Thu, 21 Apr 2022 20:49:21 +0000

Como começar a programar em Perl da maneira correta. ~~(Diferente de mim)~~

Perl Orientado a Objeto Part I

Perl Orientado a Objeto Part II

Perl Orientado a Objeto Part III

Moo - Orientação de objeto minimalista

A linguagem de programação Perl

“A linguagem pretende ser prática (fácil de usar, eficiente, completa) ao invés de bonita (pequena, elegante, mínima).”

— Kirrily Robert

perlintro - a brief introduction and overview of Perl - Perldoc Browser

Vou inaugurar meu Dev.to falando mal de mim. Mas eu não seria eu mesma se não usasse um pouco a autodepreciação para, além de render umas boas risadas para mim mesma, alertar vocês de como começar a estudar uma nova linguagem de programação indicando qual o começo certo, caso você decida embarcar no Perl comigo.

O Perl é uma linguagem de programação de uso geral, criada inicialmente pra manipulações de texto (e como ele cumpre muito bem esse papel viu), mas atualmente você pode criar até um universo com ela, se for bom.

Também é uma linguagem antiga, foi criada em 1987. Por conta disso muitas pessoas me questionam “por que você escolheu Perl para trabalhar?” e o que mais costumo responder é: Eu não escolhi o Perl para trabalhar, foi ele quem me escolheu. Mas se fosse contar essa história ocuparia todo o post. Então vamos por a mão na massa.

⚠️ Este post tem como objetivo definir orientação a objeto com Perl de maneira descontraída, por tanto ele leva em consideração que você, leitor, tenha conhecimento de lógica e linguagem e programação e saiba algumas definições de orientação a objeto.

Programação Orientada a Objeto

A Programação Orientada a Objetos é um dos quatro paradigmas da programação, juntamente com: imperativa, funcional e lógica. Ela se baseia na composição (atributos) e e interação (métodos) de objetos.
Perl é uma linguagem multiplataforma, e apenas a partir da sua versão 5 que ela passou a dar suporte para orientação a objeto.

Para aplicar a orientação a objeto em Perl é muito simples. Veja a seguir:

Classes

As classes são os pacotes dos arquivos que tem construtores que retornam objetos;

package model::Performances; # General Class

Objetos

Os objetos em Perl são estruturas de dados que agrupam atributos e métodos das nossas classes.

Construtor

A criação de um construtor no perl pode ser feita de maneira simples, usando uma de suas sub-rotinas para retornar a estrutura de dados abençoada (objeto) com todos os atributos de sua classe. O nome da sub-rotina não importa muito, mas por convenção e boas práticas de programação usamos o new(). A seguir podemos ver um exemplo.

package model::Performances; # General Class

sub new { # Constructor
    my $this = shift;
    my $class = ref ($this) || $this;
    # Attributes in classes
    my $self = {
        name => shift,
        audience => shift,
        type_play => shift,
    };

    return bless $self, $class;
}

Métodos

O método simplesmente é uma sub-rotina regular dentro de uma classe.

sub amount_for { # Method
    my $self = shift; 
    return ($self->audience * 1000) / $self->type_play;
}

👋🏻 Então pessoal, esses foram os conceitos mais básicos de orientação a objeto no perl. Continuem de olho que logo mais farei publicações sobre Polimorfismo, Herança e Encapsulamento e outras aplicações voltadas a essa linguagem de programação tão abrangente. Até a próxima.