Is Perl an Object Oriented Programming Language?


Scott Campbell

In the world of programming languages, there are several paradigms that define how code is organized and executed. One such paradigm is Object-Oriented Programming (OOP), which allows developers to create and manipulate objects that contain both data and behavior. One popular language often associated with OOP is Perl.

What is Perl?

Perl, short for Practical Extraction and Reporting Language, was created by Larry Wall in the late 1980s. It was designed to be a versatile scripting language that combines features from various other languages like C, sed, awk, and shell scripting. Perl gained popularity due to its powerful text manipulation capabilities and its ability to handle complex tasks with ease.

Over the years, Perl has evolved significantly and has become widely used for various purposes, including web development, system administration, network programming, and more. It offers a vast collection of modules through the Comprehensive Perl Archive Network (CPAN), making it highly extensible and adaptable for different projects.

Object-Oriented Programming in Perl

While Perl is primarily known as a procedural programming language, it does support object-oriented programming concepts. However, it’s important to note that Perl’s approach to OOP differs from other languages like Java or Python.

In Perl, objects are created using packages, which act as templates for creating multiple instances of objects. Packages define a set of data structures (attributes) and associated behaviors (methods) that can be used by objects created from them.

To create an object in Perl, you need to instantiate a package using the bless function. This function associates an instance of a package with a reference or variable.

# Creating a package
package MyClass;

sub new {
    my $class = shift;
    my $self = {
        name => shift,
        age => shift
    bless $self, $class;
    return $self;

sub get_name {
    my ($self) = @_;
    return $self->{name};

sub get_age {
    my ($self) = @_;
    return $self->{age};

1; # End of package

In the example above, we define a package named MyClass that represents a simple class with attributes name and age. The new method is used to create an instance of the class and initialize its attributes. The bless function is used to associate the instance with the class.

We also define two methods, get_name and get_age, which allow us to retrieve the values of the attributes from an object.

Inheritance in Perl

In addition to basic object creation, Perl also supports inheritance, which is a fundamental concept in OOP. Inheritance allows one class to inherit attributes and behaviors from another class. This promotes code reuse and modularity.

To implement inheritance in Perl, you can use the @ISA array, which contains the names of parent classes that a package inherits from. By adding a parent class to this array, you can access its methods and attributes within the child class.

# Creating a child class
package MySubClass;

our @ISA = qw(MyClass);

sub new {
my $class = shift;
my ($name, $age) = @_;
my $self = $class->SUPER::new($name, $age);
bless $self, $class;
return $self;

In the example above, we create a child class named MySubClass that inherits from the MyClass class. By using the @ISA array and calling the parent class's constructor method (SUPER::new), we can initialize the attributes of the parent class within the child class.


In summary, while Perl is often considered a procedural programming language, it does offer support for object-oriented programming concepts like packages, object instantiation, methods, and inheritance. Although Perl's approach to OOP may differ from other languages, it still provides developers with the flexibility to create and manipulate objects in their code.

If you are familiar with other object-oriented languages like Java or Python, learning Perl's approach to OOP may require some adjustment. However, once you grasp the concepts and syntax unique to Perl, you can leverage its power and versatility to build robust applications.