¿Cómo creo una clase de Perl?

oop

Question

Estoy escribiendo clases de Perl para eliminar redundancias de los scripts y, dado que Perl tiene muchas formas de crear clases, sigo teniendo problemas para hacer las clases correctamente. Entonces, ¿alguien tiene un ejemplo de mejor práctica de una clase?

La pregunta más importante que tengo es si no debería haber variables globales en un módulo. ¿Cómo se usan las variables en sub () en un módulo? Al igual que Java self-> foo = 10;

Básicamente, solo dame una clase escrita en Java o C # o incluso C ++ y escribe lo mismo en Perl. También puntos adicionales para mostrar cómo hacer las variables de clase privada, protegida y pública correctamente. La herencia y las interfaces serían útiles, supongo.

Answer 1

Además de los alces, que la gente ya ha mencionado ...

Si solo está hablando de clases (por lo tanto, no de objetos), normalmente crea datos de clase con variables léxicas en el ámbito del archivo y utiliza una clase por archivo. Se crean métodos de acceso para tratar con ellos. Hay varias maneras en que puedes lidiar con eso.

Sin embargo, parece que necesitas comenzar con algo como Perl intermedio o Perl orientado a objetos de Damian Conway. Hay mucho que explicar para que cualquiera se tome el tiempo de reproducir todo eso en una respuesta de .

Answer 2

Bueno, el Perl es fácil, pero estoy oxidado en otros idiomas, así que actualizaré con ellos en un momento. Aquí hay una clase de Perl simple:

#!/usr/bin/perl
package Person;
use strict;
use warnings;
use Carp;
sub new {
my $class = shift;
my $self = { @_ };
croak "bad arguments" unless defined $self->{firstname} and defined $self->{lastname};
return bless $self, $class; #this is what makes a reference into an object
}
sub name {
my $self = shift;
return "$self->{firstname} $self->{lastname}";
}
#and here is some code that uses it
package main;
my $person = Person->new(firstname => "Chas.", lastname => "Owens");
print $person->name, "/n";

Aquí está la misma clase escrita usando los nuevos objetos de estilo Moose:

#!/usr/bin/perl
package Person;
use Moose; #does use strict; use warnings; for you
has firstname => ( is => ''rw'', isa => ''Str'', required => 1 );
has lastname => ( is => ''rw'', isa => ''Str'', required => 1 );
sub name {
my $self = shift;
return $self->firstname . " " . $self->lastname;
}
#and here is some code that uses it
package main;
my $person = Person->new(firstname => "Chas.", lastname => "Owens");
print $person->name, "/n";

Y MooseX :: Declare elimina la necesidad de aún más código y hace que las cosas se vean bien:

#!/usr/bin/perl
use MooseX::Declare;
class Person {
has firstname => ( is => ''rw'', isa => ''Str'', required => 1 );
has lastname => ( is => ''rw'', isa => ''Str'', required => 1 );
method name {
return $self->firstname . " " . $self->lastname;
}
}
#and here is some code that uses it
package main;
my $person = Person->new(firstname => "Chas.", lastname => "Owens");
print $person->name, "/n";

Una nota rápida: Estas dos clases son las dos primeras clases de Moose que he escrito. Y aquí hay un código C ++ muy oxidado (no se corte con él o necesitará una vacuna contra el tétanos):

#include <stdio.h>
#include <string.h>
class Person {
char* firstname;
char* lastname;
public:
Person(char* first, char* last) {
firstname = first;
lastname = last;
}
char* name(void) {
int len = strlen(firstname) + strlen(lastname) + 1;
char* name = new char[len];
name[0] = ''/0'';
strcat(name, firstname);
strcat(name, " ");
strcat(name, lastname);
return name;
}
};
int main(void) {
Person* p = new Person("Chas.", "Owens");
char* name = p->name();
printf("%s/n", name);
delete name;
delete p;
return 0;
}

Answer 3

Echa un vistazo a Moose , que es una extensión del sistema de objetos Perl 5.

Lo siguiente te ayudará a aprender Moose:

• Moose::Manual
• Moose::Cookbook

Answer 4

Una forma típica de crear objetos Perl es "bendecir" un hashref. La instancia de objeto puede entonces almacenar datos contra su propio conjunto de claves hash.

package SampleObject;
use strict;
use warnings;
sub new {
my ($class, %args) = @_;
return bless { %args }, $class;
}
sub sample_method {
my ($self) = @_;
print $self->{sample_data};
}

y uso:

my $obj = SampleObject->new( sample_data => ''hello world'',
more_data => ''blah blah blah'' );
$obj->sample_method();

Alternativamente, se pueden agregar métodos accessor / mutator (vea Class :: Accessor, Class :: Accessor :: Chained, etc. para una fácil configuración de estos); esto facilita la validación de datos y la encapsulación agregada (no se aplica en Perl, tienes que asegurarte de que tu código no circule por un accesor / mutador adecuado y acceder a los datos en el bendito hashref directamente).