Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"
Let The Music Play: Join EFF Today

 Create an AccountHome | Submit News | Your Account  

Tutorial Menu
Linux Tutorial Home
Table of Contents

· Introduction to Operating Systems
· Linux Basics
· Working with the System
· Shells and Utilities
· Editing Files
· Basic Administration
· The Operating System
· The X Windowing System
· The Computer Itself
· Networking
· System Monitoring
· Solving Problems
· Security
· Installing and Upgrading
· Linux and Windows

Man Pages
Linux Topics
Test Your Knowledge

Site Menu
Site Map
Copyright Info
Terms of Use
Privacy Info
Masthead / Impressum
Your Account

Private Messages

News Archive
Submit News
User Articles
Web Links


The Web

Who's Online
There are currently, 70 guest(s) and 0 member(s) that are online.

You are an Anonymous user. You can register for free by clicking here




       Declaration and Access of Arrays of Arrays

       The simplest thing to build is an array of arrays (some­
       times imprecisely called a list of lists).  It's reason­
       ably easy to understand, and almost everything that
       applies here will also be applicable later on with the
       fancier data structures.

       An array of an array is just a regular old array @AoA that
       you can get at with two subscripts, like $AoA[3][2].
       Here's a declaration of the array:

           # assign to our array, an array of array references
           @AoA = (
                  [ "fred", "barney" ],
                  [ "george", "jane", "elroy" ],
                  [ "homer", "marge", "bart" ],

           print $AoA[2][2];

       Now you should be very careful that the outer bracket type
       is a round one, that is, a parenthesis.  That's because
       you're assigning to an @array, so you need parentheses.
       If you wanted there not to be an @AoA, but rather just a
       reference to it, you could do something more like this:

           # assign a reference to array of array references
           $ref_to_AoA = [
               [ "fred", "barney", "pebbles", "bambam", "dino", ],
               [ "homer", "bart", "marge", "maggie", ],
               [ "george", "jane", "elroy", "judy", ],

           print $ref_to_AoA->[2][2];

       Notice that the outer bracket type has changed, and so our
       access syntax has also changed.  That's because unlike C,
       in perl you can't freely interchange arrays and references
       thereto.  $ref_to_AoA is a reference to an array, whereas
       @AoA is an array proper.  Likewise, $AoA[2] is not an
       array, but an array ref.  So how come you can write these:


       instead of having to write these:


       First, let's look at reading it in from a file.  This is
       something like adding a row at a time.  We'll assume that
       there's a flat file in which each line is a row and each
       word an element.  If you're trying to develop an @AoA
       array containing all these, here's the right way to do

           while (<>) {
               @tmp = split;
               push @AoA, [ @tmp ];

       You might also have loaded that from a function:

           for $i ( 1 .. 10 ) {
               $AoA[$i] = [ somefunc($i) ];

       Or you might have had a temporary variable sitting around
       with the array in it.

           for $i ( 1 .. 10 ) {
               @tmp = somefunc($i);
               $AoA[$i] = [ @tmp ];

       It's very important that you make sure to use the "[]"
       array reference constructor.  That's because this will be
       very wrong:

           $AoA[$i] = @tmp;

       You see, assigning a named array like that to a scalar
       just counts the number of elements in @tmp, which probably
       isn't what you want.

       If you are running under "use strict", you'll have to add
       some declarations to make it happy:

           use strict;
           my(@AoA, @tmp);
           while (<>) {
               @tmp = split;
               push @AoA, [ @tmp ];

       Of course, you don't need the temporary array to have a
       name at all:

           while (<>) {
               push @AoA, [ split ];

           my (@AoA, $i);
           for $i ( 0 .. 10 ) {
               $AoA[$i] = [ split ' ', <> ];

       You should in general be leery of using functions that
       could potentially return lists in scalar context without
       explicitly stating such.  This would be clearer to the
       casual reader:

           my (@AoA, $i);
           for $i ( 0 .. 10 ) {
               $AoA[$i] = [ split ' ', scalar(<>) ];

       If you wanted to have a $ref_to_AoA variable as a refer­
       ence to an array, you'd have to do something like this:

           while (<>) {
               push @$ref_to_AoA, [ split ];

       Now you can add new rows.  What about adding new columns?
       If you're dealing with just matrices, it's often easiest
       to use simple assignment:

           for $x (1 .. 10) {
               for $y (1 .. 10) {
                   $AoA[$x][$y] = func($x, $y);

           for $x ( 3, 7, 9 ) {
               $AoA[$x][20] += func2($x);

       It doesn't matter whether those elements are already there
       or not: it'll gladly create them for you, setting inter­
       vening elements to "undef" as need be.

       If you wanted just to append to a row, you'd have to do
       something a bit funnier looking:

           # add new columns to an existing row
           push @{ $AoA[0] }, "wilma", "betty";

       Notice that I couldn't say just:

           push $AoA[0], "wilma", "betty";  # WRONG!

       In fact, that wouldn't even compile.  How come?  Because
           print @AoA;         # WRONG

       because you'll get just references listed, and perl will
       never automatically dereference things for you.  Instead,
       you have to roll yourself a loop or two.  This prints the
       whole structure, using the shell-style for() construct to
       loop across the outer set of subscripts.

           for $aref ( @AoA ) {
               print "\t [ @$aref ],\n";

       If you wanted to keep track of subscripts, you might do

           for $i ( 0 .. $#AoA ) {
               print "\t elt $i is [ @{$AoA[$i]} ],\n";

       or maybe even this.  Notice the inner loop.

           for $i ( 0 .. $#AoA ) {
               for $j ( 0 .. $#{$AoA[$i]} ) {
                   print "elt $i $j is $AoA[$i][$j]\n";

       As you can see, it's getting a bit complicated.  That's
       why sometimes is easier to take a temporary on your way

           for $i ( 0 .. $#AoA ) {
               $aref = $AoA[$i];
               for $j ( 0 .. $#{$aref} ) {
                   print "elt $i $j is $AoA[$i][$j]\n";

       Hmm... that's still a bit ugly.  How about this:

           for $i ( 0 .. $#AoA ) {
               $aref = $AoA[$i];
               $n = @$aref - 1;
               for $j ( 0 .. $n ) {
                   print "elt $i $j is $AoA[$i][$j]\n";


       If you want to get at a slice (part of a row) in a multi­
       dimensional array, you're going to have to do some fancy

       That same loop could be replaced with a slice operation:

           @part = @{ $AoA[4] } [ 7..12 ];

       but as you might well imagine, this is pretty rough on the

       Ah, but what if you wanted a two-dimensional slice, such
       as having $x run from 4..8 and $y run from 7 to 12?
       Hmm... here's the simple way:

           @newAoA = ();
           for ($startx = $x = 4; $x <= 8; $x++) {
               for ($starty = $y = 7; $y <= 12; $y++) {
                   $newAoA[$x - $startx][$y - $starty] = $AoA[$x][$y];

       We can reduce some of the looping through slices

           for ($x = 4; $x <= 8; $x++) {
               push @newAoA, [ @{ $AoA[$x] } [ 7..12 ] ];

       If you were into Schwartzian Transforms, you would proba­
       bly have selected map for that

           @newAoA = map { [ @{ $AoA[$_] } [ 7..12 ] ] } 4 .. 8;

       Although if your manager accused of seeking job security
       (or rapid insecurity) through inscrutable code, it would
       be hard to argue. :-) If I were you, I'd put that in a

           @newAoA = splice_2D( \@AoA, 4 => 8, 7 => 12 );
           sub splice_2D {
               my $lrr = shift;        # ref to array of array refs!
               my ($x_lo, $x_hi,
                   $y_lo, $y_hi) = @_;

               return map {
                   [ @{ $lrr->[$_] } [ $y_lo .. $y_hi ] ]
               } $x_lo .. $x_hi;


       perldata(1), perlref(1), perldsc(1)


       Tom Christiansen <tchrist@perl.com>


More information about the site can be found in the FAQ



Security Code
Security Code
Type Security Code

Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name.

Help if you can!

Amazon Wish List

Did You Know?
The Linux Tutorial welcomes your suggestions and ideas.


Tell a Friend About Us

Bookmark and Share

Web site powered by PHP-Nuke

Is this information useful? At the very least you can help by spreading the word to your favorite newsgroups, mailing lists and forums.
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters. Articles are the property of their respective owners. Unless otherwise stated in the body of the article, article content (C) 1994-2013 by James Mohr. All rights reserved. The stylized page/paper, as well as the terms "The Linux Tutorial", "The Linux Server Tutorial", "The Linux Knowledge Base and Tutorial" and "The place where you learn Linux" are service marks of James Mohr. All rights reserved.
The Linux Knowledge Base and Tutorial may contain links to sites on the Internet, which are owned and operated by third parties. The Linux Tutorial is not responsible for the content of any such third-party site. By viewing/utilizing this web site, you have agreed to our disclaimer, terms of use and privacy policy. Use of automated download software ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and are therefore expressly prohibited. For more details on this, take a look here

PHP-Nuke Copyright © 2004 by Francisco Burzi. This is free software, and you may redistribute it under the GPL. PHP-Nuke comes with absolutely no warranty, for details, see the license.
Page Generation: 0.09 Seconds