Hash References To get a hash reference, use the {key=>value} syntax instead, or prefix your variable name with a backslash like: %hash. Dereference a hash with %$hashref, with the $arrayref->{key} arrow for value references, or the %{array_ref_expression} syntax.

The following works for me just fine under perl 5.10 and 5.14: use strict; use Data::Dumper; my @array= qw(foo 42 bar); my %hash; @{ $hash{key} } = @array; $hash{key} = [ @array ]; #same as above line print Dumper(/%hash,$hash{key}[1]);

Creating a reference to a Perl array If we have an array called @names, we can create a reference to the array using a back-slash / in-front of the variable: my $names_ref = /@names;. We use the _ref extension so it will stand out for us that we expect to have a reference in that scalar.

A Perl reference is a scalar data type that holds the location of another value which could be scalar, arrays, or hashes. Because of its scalar nature, a reference can be used anywhere, a scalar can be used. You can construct lists containing references to other lists, which can contain references to hashes, and so on.

1. Array references—which anonymous arrays are one type of—allows Perl to treat the array as a single item. This allows you to build complex, nested data structures as well. This applies to hash, code, and all the other reference types too, but here I’ll show only the hash reference.

A Perl hash is defined by key-value pairs. Perl stores elements of a hash in such an optimal way that you can look up its values based on keys very fast. Like a scalar or an array variable, a hash variable has its own prefix. A hash variable must begin with a percent sign (%).

Simple keys and values

1. use strict;
2. use warnings;
3. use Data::Dumper qw(Dumper);
4. my @keys = (‘one’, ‘two’, ‘three’);
5. my @values = (‘uno’, ‘dos’, ‘tres’);
6. my %hash;
7. @hash{@keys} = @values;
8. print Dumper /%hash;

A reference holds a memory address of the object that it points to. When a reference is dereferenced, you can manipulate data of the object that the reference refers to. The act of retrieving data through a reference is called dereferencing.

Advertisements. Variables are the reserved memory locations to store values. This means that when you create a variable you reserve some space in memory. Based on the data type of a variable, the interpreter allocates memory and decides what can be stored in the reserved memory.

An anonymous hash is simply a hash without a name. Both named and anonymous hashes have references, and /%hash is no more a direct reference than { foo => “bar” } .

A Perl hash is defined by key-value pairs. Perl stores elements of a hash in such an optimal way that you can look up its values based on keys very fast. With the array, you use indices to access its elements. However, you must use descriptive keys to access hash’s element. A hash is sometimes referred to as an associative array.

%scores_of is a hash of arrays or more precisely it is a hash of array references. The back-slash // in-front of the @ character returns the reference to the array. The call to Dumper show what do we have in the hash.

Basically, if you see such value printed somewhere, you know that the code is accessing a reference to an array and that you should probably change the code to access the content of that array. If you have a reference to an array and if you would like to access the content of the array you need to dereference the array reference .

As Perl data structures make you store a reference to a hash rather than the actual hash, you need these to construct the references. You can do this in two steps like this: You don’t need the quotes inside of the {} when referencing a hash key, although some people consider quotes on a hash key to be good practice.