CODEWITHSUNDEEP
perlhash
Trevor
Trevor

Reputation: 6689

Object as hash key

Is it possible to use an object as a hash key?

For example, the following code allows me to use an instance of MyClass as a key but when I iterate over the keys and attempt to invoke the get_value method, I get the error:

Can't locate object method "get_value" via package "MyClass=HASH(0x12a4040)" (perhaps you forgot to load "MyClass=HASH(0x12a4040)"?)

package MyClass;
use strict;

sub new
{
    my $class = shift;
    my $self = {
        _value => shift
    };
    bless $self, $class;
    return $self;
}

sub get_value {
    my($self) = @_;
    return $self->{_value};
}

my %hash = ();
%hash->{new MyClass(1)} = 0;
%hash->{new MyClass(2)} = 1;

for my $key (keys %hash)
{
    print $key->get_value;
}

Upvotes: 15

Views: 6004

Answers (3)

KJ7LNW
KJ7LNW

Reputation: 1901

For those hashing on objects serialized with JSON using convert_blessed:

We were serializing objects that stringify using JSON's TO_JSON hook and returned an object of hashes:

package FromAbove;

sub new { 
  my ($class, %args) = @_;
  return bless(\%args, $class)
}

sub TO_JSON {
  my $self = shift;
  return { %$self };
}
1;

and later, using JSON::to_json to stringify:

my $object_from_above = FromAbove->new( a => { b => 'c'}, d => [1, 2, 3] );
my $json_string = JSON::to_json($object_from_above, { convert_blessed => 1 });

Perl was inconsistently re-ordering the a and d keys which made hashing on the stringified object unreliable.

The fix is to use the canonical option, like so:

my $json_string = JSON::to_json($object_from_above, {
  convert_blessed => 1,
  canonical => 1 # the fix
});

NB: Big objects will have huge JSON keys, so beware...

Upvotes: 1

friedo
friedo

Reputation: 66957

Anything used as a hash key is stringified. So when using your object as a hash key, you're only getting a string representation of it and not the actual object itself.

The real question is, why in the world would you want to do this?

Also, the syntax for assigning values to a hash is $hash{key} = $val; the arrow is used when you're dealing with a hash reference.

If you want to associate objects with some other value, one way would be to use an array of hashes, e.g.

my @foo;
push @foo, { obj => MyClass->new( 1 ), val => 0 };
push @foo, { obj => MyClass->new( 2 ), val => 1 };

Then you could call $foo[0]{obj}->get_value();

If you just want your objects to be able to return some unique per-instance ID, you could add a method that takes advantage of Scalar::Util's refaddr operator:

use Scalar::Util 'refaddr';

sub unique_id { 
    my $self = shift;
    return refaddr $self;
}

...

$hash{MyClass->new(1)->unique_id} = 0;

For more: perlobj, perldata, perlreftut, Scalar::Util

Upvotes: 9

Eric Strom
Eric Strom

Reputation: 40142

By default, all hash keys in Perl are strings, so what is happening in you code (which has other problems as well), is you are converting the object to a string and storing the string.

In general, if you want to use a object as a key, the simplest way to do it is to use two data structures, one that holds your objects (an array), and another that maps the objects to some values (a hash). It is also possible to create a tied hash which will support objects as keys, but in general, tied hashes are going to be slower than simply using two data structures.

The standard module Tie::RefHash provides a mechanism for using objects (and other references) as hash keys (that work properly when you get them back).

use Tie::RefHash;
tie my %hash, 'Tie::RefHash';

$hash{MyClass->new(1)} = 0;  # never use the indirect object syntax
....

Upvotes: 21

Related Questions