How to use Bless Operator in Perl?

Question

can anyone please explain the importance and how to use bless in perl. I have read many threads on stack overflow on bless but they are not clear.

Answer 1

This is a way to make Perl treat packages as object oriented classes, and the blessed objects as instances of those classes.

Blessing a reference marks it so that the interpreter knows what package it is associated with. For example, if you write:

$x = {}; bless $x, "somepackage";

Then you can later write:

$x->method(1, 2, 3);

And the interpreter will treat this as:

somepackage::method($x, 1, 2, 3);

Here's a real simple example. Create a class in a file called MyClass.pm:

package MyClass;

sub new {
   my ($class_name) = @_;
   my $new_instance = {};
   bless $new_instance, $class_name;
   return $new_instance;
}

sub set {
   my ($self, $name, $value) = @_;
   $self->{$name} = $value;
}

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

Now you can use the class in your code:

import MyClass;

my $instance = MyClass->new; # Same as MyClass::new("MyClass")
$instance->set('age', 30);   # Same as MyClass::set($instance, 'age', 30)
print $instance->get('age'); # Same as MyClass::get($instance, 'age')

The arrow operator, combined with how bless binds a reference to a package name, gives you nice object-oriented syntax.

Answer 2

The very top of the perlobj documentation gives a helpful explanation with examples.

An Object is Simply a Data Structure

Unlike many other languages which support object orientation, Perl does not provide any special syntax for constructing an object. Objects are merely Perl data structures (hashes, arrays, scalars, filehandles, etc.) that have been explicitly associated with a particular class.

That explicit association is created by the built-in bless function, which is typically used within the constructor subroutine of the class.

Here is a simple constructor:

package File;

sub new {
    my $class = shift;

    return bless {}, $class;
}

The name new isn't special. We could name our constructor something else:

package File;

sub load {
    my $class = shift;
    return bless {}, $class;
}

The modern convention for OO modules is to always use new as the name for the constructor, but there is no requirement to do so. Any subroutine that blesses a data structure into a class is a valid constructor in Perl.

In the previous examples, the {} code creates a reference to an empty anonymous hash. The bless function then takes that reference and associates the hash with the class in $class. In the simplest case, the $class variable will end up containing the string "File".

We can also use a variable to store a reference to the data structure that is being blessed as our object:

sub new {
    my $class = shift;

    my $self = {};
    bless $self, $class;

    return $self;
}

Once we’ve blessed the hash referred to by $self we can start calling methods on it.

Answer 3

bless is an older way to construct objects in Perl. For new code, I would recommend using Moose, Moo, or Object::Tiny instead.

Those are options are ordered from the largest in size and complexity (Moose) to the simplest with least features (Object::Tiny).

If you see bless in other perl code, it works as the other answers describe.