Perl – Atributos en Programación Orientada a Objetos

En Perl , el concepto de orientación a objetos se basa en gran medida en referencias y arrays/hashes . Los pocos términos principales de la programación orientada a objetos con respecto a la programación Perl son objeto, clase y método.

• En Perl, un objeto es como una referencia a un tipo de datos que conoce la clase a la que pertenece. El objeto se almacena como una referencia presente en la variable escalar. Y dado que escalar solo contiene una referencia al objeto, incluso puede contener diferentes objetos presentes en clases separadas.
• En Perl, un paquete que contiene los métodos correspondientes que se requieren para crear y manipular objetos se conoce como clase .
• En Perl, el método es una subrutina que se define dentro del paquete. Un nombre de paquete o una referencia de objeto es el primer argumento del método dependiendo de si el método afecta a la clase u objeto actual.

Atributos

Los atributos pueden ser definidos por cada clase. Cuando los representamos como objetos, asignamos valores a esos atributos. Por ejemplo, incluso cada objeto ‘archivo’ tiene una ruta. Los atributos también se conocen como propiedades.

Los atributos se definen normalmente como de solo lectura o de lectura y escritura. Los atributos de solo lectura se pueden establecer solo cuando se crea el objeto, mientras que los atributos de lectura y escritura se pueden modificar en cualquier momento. El valor de un atributo puede ser en sí mismo otro objeto. Y no es necesario que cada clase tenga atributos y métodos.

Perl no tiene una sintaxis especial para los atributos. En la parte posterior, los atributos a menudo se almacenan como claves en el hash subyacente del objeto.

sub new{
    my ($class, $args) = @_;
    my $self = bless { serial => $args->{serial},
                       name => $args->{name},
                       price => $args->{price}
                     }, $class;
}

Cada vez que llamamos al método new(), Perl pasa automáticamente el nombre de la clase como primer argumento a la array especial @_.
Cuando creamos un objeto, en realidad creamos una referencia que conoce la clase a la que pertenece. Bless (que es una función integrada) se usa para bendecir la referencia a la clase y luego devolver una instancia de la clase. En el ejemplo anterior, hemos pasado una referencia hash a la función bless(). Pero uno puede pasar cualquier tipo de referencia a la función bless, por ejemplo, una referencia de array, lo que hace que sea mucho más fácil trabajar con una referencia hash.

Creación de valores de atributos predeterminados

Ahora podemos saber cómo aplicar atributos. Pero, ¿qué pasará si no pasamos todos los argumentos en nuestro programa Perl? En este caso, el objeto inicializará los atributos como «nulo». Por lo tanto, hay una forma de evitarlo estableciendo valores predeterminados que se anulan si el argumento está presente cuando se construye el objeto. Lógico u operador || se puede utilizar para lograr este efecto.

sub new{
sub new{
    my ($class, $args) = @_;
    my $self = {
                    name => $args->{name} || ‘iPhone XR’,
                    price => $args->{price} || ‘52K’,
               },
    Return bless $self, $class;
}
1;

Accediendo a los atributos

La mejor manera de acceder a los atributos es a través de métodos de acceso. Estos son métodos que nos ayudan en Perl a obtener o establecer el valor de cada atributo. 

Los dos tipos de acceso son: 

• Getter: Obtiene el valor del atributo.
• Setter (también conocido como Mutator): Establece el valor de los atributos.

package Person;
use strict;
use warnings;
sub new {
    my ($class, %args) = @_;
   
    my $self = \%args;
   
    bless $self, $class;
   
    return $self;
}
   
sub name {
    my ($self, $value) = @_;
    if (@_ == 2)
    {
        $self->{name} = $value;
    }
    return $self->{name};
}
1;
 
# Assigning the object 'Person'
# to the $teacher variable.
my $teacher = Person->new;
 
# Setting the attribute 'name'
# to the variable '$teacher'
$teacher->name('Foo');
 
printf $teacher->name;

Foo

Estamos llamando al constructor aquí Person->new, que devuelve un objeto que asignamos a $teacher y luego estamos llamando al accessor $teacher->name(‘Foo’) usándolo como un setter proporcionándole un valor y luego usando el mismo acceso que un getter $teacher->name (sin pasar un valor) haciendo que obtenga el valor actual del atributo mientras usa el mismo método llamado ‘name’. 
Cuando llamamos a $teacher->name(‘Foo’) , Perl notará que $teacher es una referencia bendita a un hash y fue bendecido en la Persona (espacio de nombres). Si no hubiera una bendita referencia, no habría sabido qué hacer con la flecha y el «nombre» después de eso y habría arrojado una excepción:(No se puede llamar al método… en una referencia no bendecida)

Bueno, dado que está bendecido en el espacio de nombres de Persona , Perl comenzará a buscar la función «nombre» en el espacio de nombres de Persona y una vez que se encuentre esa función, Perl llamará a esa función con los parámetros que le hemos pasado. pero también tomará la variable que teníamos en el lado izquierdo de la flecha y la pasará como primer argumento. ($profesor en nuestro caso) .
En nuestro ejemplo , esta función de «nombre» se llama una vez como «setter» cuando le pasamos un valor, y una vez como «getter» cuando no le pasamos ningún valor. Debido a que Perl pasa el objeto como el primer parámetro, esto significa que cuando se le llama «setter» en realidad vamos a obtener 2 parámetros y cuando se le llama «getter» vamos a obtener un parámetro.
La primera declaración en la subrutina «nombre» asigna los parámetros a las variables locales. Ahora, en la segunda declaración, Perl comprueba si la función debe actuar como captador o definidor. Perl comprueba el número de parámetros. Si obtiene dos parámetros, entonces es un setter. En este caso, toma el contenido de $self.
Si usamos la función ‘nombre’ como ‘captador’, entonces no le pasaremos ningún valor, lo que significa que $valor no estará definido, pero lo que es más importante , @_ solo tendrá un elemento. Esto omitirá la asignación y lo único que hará es devolver el valor de la clave ‘nombre’ de la referencia hash.

Conclusión: 
Esto muestra que los atributos de un objeto en Perl son solo pares clave/valor en una referencia hash.
En el ejemplo anterior, podemos ver que el setter/getter es simplemente una función simple de Perl.
Por lo tanto, también implementa que los atributos de un objeto son entradas simples en la referencia HASH que representa el objeto. La clave en el hash es el nombre del atributo y el valor respectivo en el HASH es el valor del atributo.