perl | Constructores y Destructores

Los constructores en las subrutinas de Perl devuelven un objeto que es una instancia de la clase. En Perl, la convención es llamar al constructor «nuevo» . A diferencia de muchos otros OOP , Perl no proporciona ninguna sintaxis especial para construir un objeto. Utiliza estructuras de datos (hashes, arrays, escalares) que se han asociado explícitamente con esa clase en particular.
El constructor usa la función «bendecir» en una referencia hash y el nombre de la clase (el nombre del paquete).

Diseñemos algunos códigos para una mejor explicación:
Nota: Los siguientes códigos no se ejecutarán en el IDE en línea debido al uso de paquetes. El siguiente código es una clase de Perl o un archivo de módulo. Guarde el siguiente archivo con la extensión (*.pm).

# Declaring the Package
package Area; 
  
# Declaring the Constructor method
sub new 
{
    return bless {}, shift; # blessing on the hashed 
                            # reference (which is empty).
}
  
1;

Cuando se llama al método constructor, el nombre del paquete ‘Área’ se almacena en la array predeterminada “@_” . La palabra clave «shift» se usa para tomar el nombre del paquete de «@_» y pasarlo a la función «bendecir» .

package Area;
  
sub new
{
    my $class = shift; # defining shift in $myclass
    my $self = {}; # the hashed reference
    return bless $self, $class;
}
1;

Note: "my" restricts the scope of a variable.

Los atributos en Perl se almacenan como pares de clave y valor en la referencia codificada. Además, agregando algunos atributos al código.

package Area;
  
sub new 
{
    my $class = shift;
    my $self = 
    {
        length => 2, # storing length
        width  => 3, # storing width 
    };
    return bless $self, $class;
}
1;

El código anterior (la clase de área ) tiene los dos atributos: largo y ancho . Para obtener acceso a estos atributos, otro programa Perl está diseñado para usarlos.

use strict;
use warnings;
use Area;
use feature qw/say/;
  
# creating a new Area object
my $area = Area->new;
  
say $area->{length}; #print the length
say $area->{width}; # print the width

Pasos para ejecutar el código:

1. Guarde el programa con el área del paquete en un archivo de texto llamado Area.pm.
   Nota: el nombre del archivo siempre debe ser el mismo que el nombre del paquete.
2. Ahora, guarde el programa que se utiliza para obtener acceso a los atributos definidos en el paquete con el nombre *.pl. Aquí, * puede ser cualquier nombre (en este caso es test.pl).
3. Ejecute el código guardado como test.pl en la línea de comandos de Perl mediante el comando
   perl test.pl

Producción:

Pasar atributos dinámicos:
actualice los archivos existentes con atributos dinámicos:

Áreas.pm:

package Area;
  
sub new 
{
    my ($class, $args) = @_; # since the values will be 
                             # passed dynamically
    my $self = 
    {
        length => $args->{length} || 1, # by default the value is 1 (stored)
        width  => $args->{width} || 1,  # by default the value is 1 (stored)
    };
    return bless $self, $class;
}
  
# we have added the get_area function to
# calculate the area as well
sub get_area 
{
    my $self = shift;
      
    # getting the area by multiplication
    my $area = $self->{length} * $self->{width}; 
    return $area;
}
1;

prueba.pl:

use strict;
use warnings;
use feature qw/say/;
use Area;
  
# pass length and width arguments 
# to the constructor
my $area = Area->new(
            {
                length => 2, # passing '2' as param of length
                width => 2, # passing '2' as param of width
            });
  
say $area->get_area;

Ahora, los Params

length = 2, width = 2

se pasa al paquete Área, para calcular el área del Cuadrado.

Los argumentos están contenidos en la variable de array predeterminada @_ cuando se llama a cualquier subrutina

Nota: Ahora siga el mismo proceso de ejecutar el código como se explicó anteriormente.
Producción:

Perl llama automáticamente al método destructor cuando todas las referencias a un objeto quedan fuera del alcance. Los métodos destructores son útiles si la clase crea subprocesos o archivos temporales que deben limpiarse si el objeto se destruye. Perl contiene un nombre de método especial, ‘ DESTROY ‘ para el destructor, que debe usarse en el momento de la declaración del destructor.

Sintaxis:

sub DESTROY 
{ 
    # DEFINE Destructors
    my $self = shift;
    print "Constructor Destroyed :P"; 
}

Once this snippet is added to existing file Area.pm.

La salida será algo así: