In the next few articles we are going to learn how to write Object Oriented code in Perl. We will start with some simple examples and extend them step by step. We start using Moose but we'll also learn how to create classes in other ways.
A constructor with Moose
Let's start by writing a simple script that uses the Person class.
We don't do anything special yet, just load the module and call
the constructor to create an instance.
use strict;
use warnings;
use v5.10;
use Person;
my $teacher = Person->new;
Save this in somedir/bin/app.pl
This should not be new to you as I am sure you have already used other modules in a similar way. Our focus is how the Person class was implemented:
package Person;
use Moose;
1;
That's it.
This code is saved in somedir/lib/Person.pm.
All you need to do to create a class is to create
a package with the name of the class, add use Moose; to it,
end the file with a true value, and save it in a file with
the same name (case sensitive!) as the package, and with a .pm extension.
Loading Moose automatically sets up use strict and use warnings.
This is nice, but be careful you don't get so used to the convenience that you
forget them in non-Moose code.
Loading Moose also automatically adds a default constructor called new.
As a side note, it is not a requirement in Perl that the constructor will be called new, but in most cases that's what the author chooses anyway.
Attributes and accessors
Having an empty class is not much fun. Let's go further in our use:
use strict;
use warnings;
use v5.10;
use Person;
my $teacher = Person->new;
$teacher->name('Joe');
say $teacher->name;
In this code, after creating the object, we call the "name" method
with a string as a parameter; this sets the "name" attribute of the class
to be 'Joe'. Because this method sets the respective attribute it is also called a
setter.
Then we call the same method again, this time without any parameter. That will fetch
the value previously stored. Because this gets the value this is also called a
getter.
In our case the getter and the setter have the same name but
it isn't a requirement either.
In general getters and setters are called accessors.
The code implementing the new class is this:
package Person;
use Moose;
has 'name' => (is => 'rw');
1;
The new part, has 'name' => (is => 'rw'); says that
"The Person class has an attribute called 'name'
which is readable and writeable"
This automatically creates a method called "name" which becomes both a setter (for writing) and a getter (for reading).
Try the code
In order to try this create a directory called "somedir", with a subdirectory called "lib" inside it, and save the Person.pm file inside the "lib" subdirectory. Also create a subdirectory called "bin" and save the script there called person.pl.
You should have
somedir/lib/Person.pm
somedir/bin/person.pl
Open your terminal (or cmd window on Windows), change the directory to be in "somedir" and
type perl -Ilib bin/person.pl
(On MS Windows you might need to use back-slashes: \ )
Constructor parameters
In the next script we pass a key-value pair to the constructor, corresponding to the name of the attribute and its value.
use strict;
use warnings;
use v5.10;
use Person;
my $teacher = Person->new( name => 'Joe' );
say $teacher->name;
This works too with the same module as we already have:
Using the constructor to set the initial value of an attribute in this way works without making any changes to the Person module itself.
Moose automatically accepts every member (another name for attributes)
to be passed during construction.
