Object-oriented programming in Perl

Perl 4

I was following comp.lang.perl on usenet, and I started seeing chatter about something called Perl 5. Perl 5 was going to be a major rewrite, and have lots of new features—including objects.

My immediate reaction to this was

• What are these people smoking?
• Where can I get some?

Perl 5

I found the man pages for the new features. I found lexically scoped variables, which I understood. I found references, which I mostly understood. Then I found the new (whole new!) chapter titled "Perl Objects". Surely, this was where I was going to find objects.

So I read it. And after I read it, I sat there thinking, "But where are the objects?" I reread it a few times, and I circled back to some of the related documentation, like references, and I probably asked some questions on comp.lang.perl (Larry Wall was active on the group at the time). Eventually, I figured out what was going on.

Perl doesn't have anything that stands up and says, "I am an object." What Perl has is a collection of features...that conspire to support...an object-oriented programming model...if that's what you want. The whole thing has rather a done-with-mirrors character to it.

Perl objects

• references
• packages/modules
• bless
• method call syntax

References

$a = 3;
$b = 'abc';

@c = (5, 2, $a, 'xyz');

%d = (name    => 'Joe Smith',
      address => '10 Main Street',
      age     => 42,
      zip     => $zip);

To these data types, Perl 5 adds references. A reference is like a pointer in C. Internally, it really is a pointer: it holds the memory address of a variable.

You can get a reference to any variable in a Perl program by putting a backslash in front of it.

\$a
\@c
\%d

$sr = \$a;
$ar = \@c;
$hr = \%d;

$ar->[2]

Similarly, for a hash reference, you can write

$hr->{age}

Later, we'll see the arrow operator used in a similar way to make method calls.

Packages/Modules

If you have a big program with multiple subsystems, you're liable to have subroutine name conflicts

sub init
{
    # initialize network
}

sub init
{
    # initialize graphics
}

sub Network::init
{
    # initialize network
}

sub Graphics::init
{
    # initialize graphics
}

sub Firefox::Network::init
{
    # initialize network
}

sub Firefox::Graphics::init
{
    # initialize graphics
}

sub Thunderbird::Network::init
{
    # initialize network
}

#!/usr/bin/perl

use Firefox::Network;

Firefox/Network.pm

sub Firefox::Network::init
{
    # initialize Firefox::Network
}

package Firefox::Network;

sub init  # This is really Firefox::Network::init
{
    # initialize Firefox::Network
}

• the package is the name of the class
• the subroutines in the package are the methods of the class
• the code for the subroutines lives in the corresponding module

bless

%dog = (ears => "long",
	tail => "short");

$dog = \%dog;

bless $dog, "Animal::Dog"

Method Calls

$dog->bark;

• dereferences $dog to get to %dog
• gets the package that %dog was blessed into (Animal::Dog)
• looks for a bark() subroutine in that package
• calls bark(), passing the original reference as the first argument

Animal::Dog::bark($dog)

sub bark
{
    my $dog  = shift;
    my $ears = $dog->{ears};
    ...
}

You can pass additional arguments to the method in parentheses

$dog->bark('loud')

sub bark
{
    my($dog, $volume) = @_;
    ...
}

Class methods

Animal::Dog->phylum

sub Animal::Dog::phylum
{
    my $package = shift;

    return "Vertebrata";
}

sub Animal::Dog::new
{
    my($package, $ears, $tail) = @_;

    my %dog = (ears => $ears,
	       tail => $tail);

    bless \%dog, "Animal::Dog"
}

$dog = Animal::Dog->new('long', 'short');

The method call syntax using the arrow is called the "arrow", or "direct" syntax. There is an alternate syntax that you will see, called the "indirect" syntax. The indirect syntax has the method name first, followed by a package name or object reference, and then any arguments.

bark $dog;
bark $dog 'loud';

$dog = new Animal::Dog;
$dog = new Animal::Dog 'long', 'short';

$dog = new Animal::Dog;
$dog->bark;

Inheritance

@Animal::Dog::ISA = qw(Animal);

If you make a method call

$dog->bark;

Inheritance doesn't have anything to do with package namespaces. As shown, Animal::Dog inherits from Animal, but it needn't, and it can inherit from anything else that it wants to. If I wanted my dog to really bark, I might want it to inherit from a package of audio drivers, too

@Animal::Dog::ISA = qw(Animal Audio::Driver);

sub Animal::Dog::new
{
    my($package, $ears, $tail) = @_;

    my %dog = (ears => $ears,
	       tail => $tail);

    bless \%dog, $package
}

package Beagle;

Beagle::ISA = qw(Animal::Dog);

my $beagle = new Beagle;

Animal::Dog::new("Beagle")

Perl doesn't have any formal facilities for data inheritance. But every method, in whatever package, gets the object reference passed as its first argument. All the packages in the inheritance tree can store their instance data in that hash, and methods can grab whatever they need from it.

If you're worried about packages stepping on each others' hash keys, you can establish a convention for divvying up the keyspace among the packages in some way, but I've never had to do that.

Perl docs

Translations