Quick Navigation Bar
input/output :: records and references :: regular expressions
[ toc | forums ]

Note: If the document URL does not begin with http://randu.org/tutorials/perl/ then you are viewing a copy. Please direct your browser to the correct location for the most recent version.

Records and References

Like in many other high-level languages, Perl allows you to create references or indirection to another object. In C, you create indirection using pointers.
Records is a collection of data containing non-homogenous data, e.g. a mixture of scalars, arrays, hashes, other records, references, etc.
On a side note, to declare an array of arrays or (multi-dimensional arrays):
```
  @arr = (
           [ "perl", "rocks" ],
	   [ "oh", "yeah" ],
	   [ "hooray", "whoop!"],
  );
  print "$arr[1][1]\n";
```
You can also have arrays of hashes, hashes of arrays, and hashes of hashes. See Wall, Chapter 9: Data Structures for more information.

References :: Declaration and Syntax

The most typical reference in Perl is a hard reference, containing an internal glob of data. Wall calls this a "referent" (Wall 243). Below is a figure taken from Ch 8, 8-1:
```
  $foo = "bot" <---+
                   |
  $bar = \$foo ----+
```
To create references, you use the backslash operator which works like the & (address-of) operator in C:
```
  $scalarref = \$somevar;
  $constref = \3.14;
  $arrayref = \@ARGV;
  $hashref = \%somehash;
```
You can even create anonymous data inside of references. These data have no variable reference to them, they are just data sitting inside of a reference:
```
  $arrayref = [ 1, 2, ['a', 'b', 'c', 'd'] ];
```
The internal anonymous array 'a','b','c','d' has no variable associated with it, but can be accessed. $arrayref->[2][2] would result in 'c'. The arrow operator here works much like the arrow operator does in C to dereference.
To dereference a reference, you use the $ operator, which works much like the * operator does in C:
```
  $foo = "whoop";
  $fooref = \$foo;
  $outcome = $$fooref;       # $outcome holds "whoop"
```
You can have references to references (e.g. a pointer to a pointer) in Perl, for each reference, you dereference with an additonal $.

You can create references to hashes and arrays also:

  push(@$arrayref, $filename);
  $$arrayref[0] = "January";
  @$arrayref[4 .. 6] = qw/May June July/;

  %$hashref = (KEY => "RING", BIRD => "SING");
  $$hashref{KEY} = "VALUE";
  @$hashref{"KEY1", "KEY2"} = ("VAL1", "VAL2");

For more information on References, Wall, Chapter 8: References does a very nice job dealing with this topic, including symbolic references.

Records :: Declaration and Syntax

So far, we have only talked about homogenous data structures. Records gives you the ability to create non-homogenous data structures, much like structs in C.

To declare a record:

  $rec = {
    TEXT      => $string,
    LISTREF   => [ @some_list ],
    HASHREF   => { %some_hash ],
  };

Simple enough, how about accessing fields?

  print $rec->{TEXT};
  print $rec->{LISTREF}[0];
  print $rec->{HASHREF}{"key"};

You can even create a record from scratch:

  $rec = {};
  while (<>) {
    push @readlist, $_;
  }
  $rec->{LIST} = [@readlist];

Very powerful!

What if you wanted to save your complete data structure to a file? You can use the Data::Dumper module to save your records to a file without having to create a method to save them separately by fields and read them in. Larry Wall goes into detail about records, pgs. 283-287.

Records and References Review

References are a powerful tool to create indirection to other scalars, references, records, etc.
Records allow you to create mixtures of scalars, references, other records, and even self-referential records.