Data Structures: Scalars, Arrays, Hashes

• In this section, we'll discuss the basic data structures available in Perl. Make sure you practice some of the examples discussed here!

Data Structures :: Scalars

• A scalar is a number or a string. You can apply the usual manipulations on numbers, +, -, *, /, %, but Perl also has an exponentional operator. So how would you write 2 cubed?

    2**3
  

  Powerful? Yes.
• What about string operations? String concatenation for example:

    "hello" . "world"
  

  The above would result in a single word, "helloworld". You can string multiple concatenations into one operation.
• There is a string repetition operator: x. For example:

    "w00t" x 3
  

  would yield "w00tw00tw00t".
• The standard logical operators are present and can be used on strings too! The following table (Schwartz 37) illustrates the Logical operators on scalars:

  Comparison	Numeric	String
  Equal	==	eq
  Not Equal	!=	ne
  Less Than	<	lt
  Greater Than	>	gt
  Less Than or Equal To	<=	le
  Greater Than or Equal To	>=	ge

• Other operators include ++, --, !, &&, ||, ?:, *= += -=, ->, \. See Schwartz pgs. 38-39.
• One of the powerhouses of Perl is the automatic type conversion between numbers and strings. It technically isn't even a type conversion because numbers and strings are both scalars.

    (4**2 + 3 / 2) . " is the result of the expression 4^2 + 3/2"
  

  This would result in a string "17.5 is the result of the expression 4^2 + 3/2".
• So how do we store these scalars into actual variables we can use? Simple:

    $result = (4**2 + 3 / 2) . " is the result of the expression 4^2 + 3/2";
  

  Now the string is stored in the variable result.
• You can do many cool things with variables in Perl, for example:

    ($x, $y) = ($y, $x);
  

  swaps variables x and y. A far cry from C...
• To remove trailing newlines from strings, you can use either chop or chomp. chop always removes the last character from the string, while chomp only removes newlines. So be safe and use chomp to remove newlines from input (more on input later).

Data Structures :: Arrays

• An array variable is signified by the @ character.
• A list literal is defined by parentheses and separated by commas:

    @arr_1 = (1, 2, 3);
    @str_arr = ("hello", "cruel", "world");
    @arr_42 = qw(the meaning of life doesn\'t exist);
    @arr_gen = (0 .. 5);
  

  str_arr is an array of strings. What is arr_42? It is the shorthand method of writing a list of strings using the qw or quote word function. arr_gen is the same as the list (0, 1, 2, 3, 4, 5).
• What about adding into an array or deleting from an array?

    @arr_gen = (-1, @arr_gen, 6);   # adds -1 to the front, 6 to the back of list
    ($a, @arr_gen) = @arr_gen;      # removes -1 from @arr_gen to $a
    $length = @arr_gen;             # length is 7 
    ($first) = @arr_gen;
  

  These aren't the only ways to add or remove from a list (see below). What does the fourth statement do? Whenever you set an array to a scalar, Perl automatically takes the length of the array and sets that value to the scalar. The last statement gets the first element of arr_gen or 0. But how do we access different elements in the array?
• Element access in arrays are much like any other programming language:

    $arr_gen[3] = 42;
    @arr_gen[0,1] = (10, 11);
  

  In the first line, we access the fourth element in the array and change the value to 42. In the second line, we change the first two elements in the array to 10 and 11 by slicing. You can easily reverse lists using slicing also (see Schwartz pg. 53), but there is an even easier method below for list reversals.
• Another powerful feature of arrays in Perl is negative indexing:

    @arr_gen = (0 .. 5);
    $a = $arr_gen[-2];    # $a gets assigned 4
    $last = $#arr_gen;    # last == 4
  

  What does the last statement do? It gives last the last index value of the array (not the length).
• So how do we add/remove from lists with ease? Simple, treat them like stacks or queues:

    @arr = (1 .. 3);
    $new_rvalue = 4;
    $new_lvalue = 0;
    push(@arr, $new_rvalue);       # @arr == (1, 2, 3, 4)
    unshift(@arr, $new_lvalue);    # @arr == (0, 1, 2, 3, 4)
    $x = pop(@arr);                # $x == 4, @arr == (0, 1, 2, 3)
    $y = shift(@arr);              # $y == 0, @arr == (1, 2, 3)
  

  Instant stacks and queues. Nice!
• How about reversing a list? Simply call the reverse function:

    @rev_a = reverse(@a);
  

  Simple enough... how about sorting a list?

    @mylist = (1, 2, 4, 0, 32, 22, 17, 53, 42);
    @sorted = sort(@mylist);
  

  @sorted is 0, 1, 17, 2, 22, 32, 4, 42, 53. Wait! That isn't sorted... well technically it is. The sort function performs an ASCII sort, not a numeric sort. More on sorting numerically later.

Data Structures :: Hashes

• A hash is a data structure that holds scalars, but is indexed by a key value or another scalar.
• Hash variables are declared with %. Elements in the hash are referenced by $key. For example:

    $myhash{"key1"} = "555-111-29391-secret-key!"
    $myhash{"key2"} = "333-123-33904-secret-key!"
    $key = "key2";
    print "$myhash{$key}";         # Prints the value in the hash of key2
  

• There are some useful hash functions:
  • keys - lists all current keys in the hash (order doesn't matter. Why? So a useful way to use the keys function call is to loop through each key in the hash perhaps:

      foreach $key (keys (%myhash)) {
        print "$myhash{$key}\n";
      }
    

    This would loop through the %myhash hash and print each key. More on foreach later...
  • values - returns a list of all values in the hash.
  • each - each works much like keys does, but returns a list of both the key and the hash value.
  • delete - deletes a value out of the hash:

      delete $myhash{"key1"};         # Deletes the key key1 and it's value
    

• Hashes can be sliced also! For example:

    @keys = qw(key3 key4 key5);
    @myhash{@keys} = ("665-345-09284-secret-key!", "958-544-94950-secret-key!",
      "448-39403-secret-key!");
  

  @myhash{@keys} is the same as @myhash{"key3", "key4", "key5"} = ("665-345-09284-secret-key!", "958-544-94950-secret-key!", "448-39403-secret-key!");

Data Structures Review

• Scalars are just numbers or strings. It's a fundamentally supported data type in Perl!
• Arrays are collections of scalars indexed by integers much like other programming languages, but Perl has powerful extras added in.
• Hashes are like arrays, but with scalar indexes.
• There are other data structures, custom records and self-referential types.

---

© 1999-2008 Alfred Park (fred AT randu.org)