As we have seen in all the languages we have studied thus far, variables are an important and sometimes confusing concept. In C++ and JAVA there are numerous types of variables, many of which are extremely similar. the only real difference is how the variables are stored, deep down in the implementation of the language. Most casual users of the big two languages know that int is for whole numbers, and float is for real numbers, but to make things confusing there is also a double which is the same thing as a float really. What about the addition of items such as long which can be used alone, or with other variable names? This is all very confusing, and in the long run, it doesn't really matter, unless you are really particular about such things.

Perl tries to insulate the user from such restrictions. Why should the programmer be burdened with information such as in what internal format a number will be stored with? In Perl, all the guess work has been taken out of variables. There are 3 basic kinds of variables in Perl:

• Scalars
  As we have seen in APL, a scalar can be described as a 'single' item. In Perl they are no different. A scalar in Perl can be a number, or a string. A number can be any numerical value, such as a whole number, or a floating point number. There is no need to declare a specific type, let the interpreter decide when it needs to. A string can be any combination of letters or other marks enclosed in quotes, just as in C++ or JAVA. Again, there is no need for special declarations. A scalar is all things to all single items.
  
  To use a scalar variable, the only thing that is required is to precede the variable name with a dollar sign ($). You can try to remember that a Scalar starts with a $ because it sort of looks like an S. This will let the compiler know that you are working with a single item. Let see some examples of Scalars in action:
  

          #!/usr/local/bin/perl -w
  	
  	$number = 5;
  
          $string = "I am a string";
  
          print "number: ", $number, "\n\n";
  
          print "string: ", $string, "\n\n";	
  	

  The output of this little script looks like so:

   
          number: 5
                                                                                  
          string: I am a string	
  	

  See how easy it is? No need to go declaring libraries, strings, integers, and the like. We will see more on how to manipulate these values later. It is interesting to note that when you want to print many things, you can separate them by a comma (this is similar to JAVA, except in JAVA you would use a +).


• Arrays
  Just as scalars are for single items, Arrays are many scalars in a group. Again, there is no specific type that you will need to declare, Arrays can house any kind of scalar value. An important, and interesting, point is that an array can house any group of scalar values, no matter what they are. This means that string values and number values can exist in the same array!
  
  Another interesting point is that it is not necessary to declare a specific size for an array; it will grow and shrink with whatever data is inside of it. Access to the array remains similar to that of C or JAVA. To let the interpreter know you are using an array, you need to precede the variable name with an at symbol (@). Try to remember that Array and At both start with A.
  
  There is a little confusion when it comes to accessing a single element in an array. It is important to note that if you are going to access a single element in an array, you shouldn't use the @ symbol, you need to use the $ symbol. The reason for this is because you are going for a single item (i.e. a scalar), so you should address it as such. The interpreter, being the nice guy most of the time, will let you still access it by the @ symbol as shown below. It is also important to note that you are allowed to access beyond the length of an array (although it is a pointless thing to do). Lets see how they work:
  

          #!/usr/local/bin/perl -w
  
          @number_array = (1, 2, 3, 4);
  
          @string_array = ("String 1", "String 2", "String 3");
  
          @mixed_array = ("Element 1", 2, "6");
  
          print "A Single Element: (Good Way) ", $number_array[0], "\n\n";
  	
  	print "A Single Element: (No So Good Way) ", @number_array[0], "\n\n";
  	
          foreach $number (@number_array) {
            print "number_array: ", $number, "\n";
          }
          print "\n";
  
          foreach $string (@string_array) {
            print "string_array: ", $string, "\n";
          }
          print "\n";
  
          foreach $mix (@mixed_array) {
            print "mixed_array: ", $mix, "\n";
          }
  
          print "\n\nGoing Beyond The End Of An Array...\n\n";		
  	
          for ($number = 1; $number <= 10; $number++) {
            print "mixed_array: ", $mixed_array[$number], "\n";
          }
          print "\n\n";	
  	

  The output of this little script looks like so:

   
  	A Single Element: (Good Way) 1
   
  	A Single Element: (No So Good Way) 1
   
  	number_array: 1
  	number_array: 2
  	number_array: 3
  	number_array: 4
   
  	string_array: String 1
  	string_array: String 2
  	string_array: String 3
   
  	mixed_array: Element 1
  	mixed_array: 2
  	mixed_array: 6
   
  	Going Beyond The End Of An Array...
   
  	mixed_array: 2
  	mixed_array: 6
  	Use of uninitialized value in print at ./Variables.pl line 41.
  	mixed_array:
  	Use of uninitialized value in print at ./Variables.pl line 41.
  	mixed_array:
  	Use of uninitialized value in print at ./Variables.pl line 41.
  	mixed_array:
  	Use of uninitialized value in print at ./Variables.pl line 41.
  	mixed_array:
  	Use of uninitialized value in print at ./Variables.pl line 41.
  	mixed_array:
  	Use of uninitialized value in print at ./Variables.pl line 41.
  	mixed_array:
  	Use of uninitialized value in print at ./Variables.pl line 41.
  	mixed_array:
  	Use of uninitialized value in print at ./Variables.pl line 41.
  	mixed_array:
  
  	

  The loops will be discussed later on, but as you can see it is very easy to store and use the array concept.


• Hashes (Associative Arrays)
  The concept of a hash may be new to some people. If you think back to your data structures class you can recall that a hash table is a data structure that is characterized by fast insertions and lookups through the usage of keys, values and a hash function. I will not go into the specifics of how it works, because it really doesn't matter in this context.
  
  The key to understanding this lies in the usage of the keys. Each 'element pair' has a unique key when it is inserted into the hash. This key can then be used to 'lookup' the pairs (the key and the value) at a later time. A hash must always start with a percent sign (%), this is meant to remind you of a pair of items.
  
  Again, it is important to note that if you are going to access a specific item, you can't use the % sign, instead you should use the $ sign to indicate a single item. The whole concept may seem confusing, so lets see an example:
  

          #!/usr/local/bin/perl -w
  
          %students = ("Bob", 80, "Sue", 99, "Frank", 67, "Ted", 65, "Jane", 78);
  
          print "Frank\t", $students{"Frank"}, "\n\n";
  
          @keys = keys(%students);
  
          foreach $key (@keys) {
            print $key, "\t", $students{$key}, "\n";
          }
          print "\n";
  
  
  
          # If you sort the keys, you can get the hash out in order.
  	
          @keys = sort(@keys);
  
          foreach $key (@keys) {
            print $key, "\t", $students{$key}, "\n";
          }
  
  
  	
          @array = ("One", "1", "Two", "2", "Three", "3");
          %hash = ();
  	
          print "\n";
  	
          for($var = 0; $var <= 4; $var += 2) {
            $hash{$array[$var]} = $array[$var+1];
          }
  	
          @keys = keys(%hash);
  	
          foreach $key (@keys) {
            print $key, "\t", $hash{$key}, "\n";
          }
  	
  	

  The output of this little script looks like so:

   
  	Frank   67
   
  	Sue     99
  	Bob     80
  	Frank   67
  	Jane    78
  	Ted     65
   
  	Bob     80
  	Frank   67
  	Jane    78
  	Sue     99
  	Ted     65
   
  	Three   3
  	Two     2
  	One     1
  	
  	

  It is important to note that this output is entirely random. The elements in a hash are not kept in any sorted order (this makes the whole thing run a lot faster). If you wish to get the elements in a sorted order, it is necessary to use some sort of sorting function, as in the second example above.
  
  In the first example above, the first element of each pair in the hash is the key. I have chosen the key to be a string value, but it could be any scalar. The second element in the pair is the value or data to the pair. It is important to always store these things in the key-value order, as well as use a unique key for each pair (duplicates will be written over). The second thing you will notice is that I create another array for the keys only, using a nice little function that will extract each key. As you can see, it is possible to access the value of each pair by using the key, and ONLY the key.
  
  The third example illustrates that you can take the elements of an array, and load them into a hash (this is a useful feature). You will note the line that says %hash = ();. This is basically a way to clear the hash out, in case it already had some stuff in it. This will eliminate errors in the long run.
  
  Remember that it is not possible to access the elements of a hash like you would access an array via the [] notation, using a loop or accessing via the $hash_name{key} are the only methods. There is also a function to extract the values (similar to extracting the keys), but more on that later.

All variable names in Perl can be up to 255 characters long, and can contain any letter, number, or underscore; no other punctuation is allowed. You must always remember to place the appropriate symbol at the start of the name ($ for scalar, @ for array, or % for hash). Declaring variables in Perl is not a requirement, as you can see from my examples. As I start to use the variable (initialize it), that is good enough for the interpreter. As we learn more about Perl, you will see that there are ways to declare variables to go along with different scopes.

Besides the three major ways of using variables, you also have the option to dynamically create and define your own variables. This is similar to JAVA and C++, and is one reason that Perl can now be classified as an Object Oriented Language.

The last variable concept we will discuss is the notion of a multi-dimensional array. There is no specific type for this, but you can easily create one using arrays, hashes, and scalars. Lets see an example:

      #!/usr/local/bin/perl -w


      @Robila = ("CMPT 183 ", "CMPT 109 ");


      %teachers_classes = (
      	      Deremer => ["CMPT 588 ", "CMPT 280 "],
      	      Koeller => ["CMPT 586 ", "CMPT 109 "],
	      Johnson => ["CMPT 372 "],
	      Bredlau => ["CMPT 583 ", "CMPT 112 ", "CMPT 109 "],
	      Boyno => ["CMPT 184 "],
      );


      # adding an array to the structure

      $teachers_classes{"Robila"} = [@Robila];


      foreach $teacher (keys %teachers_classes) {
        print $teacher, "\t", @{$teachers_classes{$teacher}}, "\n"
      }
      print "\n";


      # add another (but not as a stored array) to the structure

      $teachers_classes{Benham} = ["CMPT 576 ", "CMPT 109 "];

      foreach $teacher (keys %teachers_classes) {
        print $teacher, "\t", @{$teachers_classes{$teacher}}, "\n"
      }
      

 
      Bredlau CMPT 583 CMPT 112 CMPT 109
      Deremer CMPT 588 CMPT 280
      Johnson CMPT 372
      Robila  CMPT 183 CMPT 109
      Boyno   CMPT 184
      Koeller CMPT 586 CMPT 109
 
      Bredlau CMPT 583 CMPT 112 CMPT 109
      Deremer CMPT 588 CMPT 280
      Johnson CMPT 372
      Benham  CMPT 576 CMPT 109
      Robila  CMPT 183 CMPT 109
      Boyno   CMPT 184
      Koeller CMPT 586 CMPT 109

      

With all of these building blocks, it is possible to create very accurate and complete data structures.