Softpanorama (slightly skeptical) Open Source Software Educational Society

May the source be with you, but remember the KISS principle ;-) Softpanorama Search

Introduction to Perl for Unix System Administrators

(Perl without excessive complexity)

by Dr Nikolai Bezroukov

Prev | Up | Contents | Down | Next

2.3. Perl Variables

Second look on scalar variables

• Undef and scalar variables

• Operations of scalar variables (to be written)

Second Look on Arrays

• Undef and arrays

• Slices

• Operations on arrays

Second look on hashes (Associative arrays)

• Undef and hashes

• Operation on Hashes

Perl has just four basic types of variables:

• scalars (A scalar variable is anything that can hold one number or a string). The name of  a scalar variable should always start with $. A variable name is set up and addressed in the same way as Bourne shell variables.
• arrays (An array is essentially a list that stores many scalars in a sequence, but you can also get members of the list using an index --  an integer number starting from 0)
• associative arrays (An associative is like an array in that it stores strings in sequence but uses another string as an index to address individual items instead of a number)
• file handles Filehandles are strange creatures in Perl. They appear to be barewords -- they do not any special prefix like all previous types. They are not variables and behave more like constants.

All Perl variables have special prefixes that act much like "on the fly" declarations of the type. You can also think about $ of a function that converts to string a variable that it prefixed.

The main achievement of Perl in this area is the introduction of the undef value.  This is a very interesting and pretty innovative solution to the problem of uninitialized variables.

Second Look on Scalar variables

Let's reiterate what we already know about scalar variables from previous section. At this point I believe many suspect that scalar variables in Perl always start with $ and can hold both strings and numbers. This is true and a scalar variable always has a string value and a numeric value. Yes, any string in Perl has a numeric value, and in case of non-numeric strings it always zero.. Like C Perl is case sensitive, so variables $a and $A are different.

$price = 5.0; # this variable is assigned a numeric value
print "price=$price"; # will print 5 

If you supply the number as a string literal than string value will be stored first. It will not be converted to numeric value:

$price= '5.0';
print "price=$price"; # will print 5.0

In general variable names consists of numbers, letters and underscores, but they should not start with a number and the names like $_ and several others are special, as we'll see later.

Many Perl operations return undef to indicate unusual situations --  failure, end of file, system error, uninitialized variable, and other exceptional conditions.  There is a defined() function than allows you to check whether a variable contains the undef value. A conditional expression will not distinguish among undef, zero, the empty string, and "0", which are all considered to be false.

Note that since undef is a valid scalar, its presence doesn't necessarily indicate an exceptional condition: many built-in  functions returns undef when there no output any more (but also in case when element happens to have the value undef.)

Use of built-in function defined() upon aggregates (hashes and arrays) is not guaranteed to produce intuitive results, and should probably be avoided. When used on the element of an associative array (hash -- see below), it tells you whether the value is defined, not whether the key exists in the hash. Use exists for the latter purpose.

That leads to the major difference between Perl and most of compiled languages (C, Pascal, etc.) -- a scalar variable can be used without initial assignment a value to it. In this case it has a default value undef  that can be converted to string (resulting in zero length string)  or to numeric value (resulting in 0). 

In numeric operations the undef value is converted to zero much like and string literal. So it is perfectly legal to write

$k=$i+0; 

Let's assume that at in this expression the variable $i is undefined and uninitialized. It is first created with initial value undef. Then because operator "+" requires numeric value it is converted to a numeric value (zero). Uninitialized value can also be used for comparison -- they will be converted according to the operator either to text value (zero length string) or numeric value (zero).

If you need to test whether or not a scalar has initialized you can use defined function. For example, if argument was passed to a subroutine then the corresponding variable can be either defined or undefined. If it is not defined, then you need to assign default value to it providing Perl with the capability to set default variables to subroutine parameters. We will learn about them more later.

From logical standpoint you cannot use undef  in comparison because the type of variable in Perl is determined by an operator and should be either numeric or string depending on context:

 if ( $arg1 == undef ) {...} # undef will always be converted to zero first

The undef value is often used in Perl  instead of exceptions to signal end of the data stream (Perl 5 does not support the notion of exceptions).  For example as we will see in Ch.4, when you read the file and reach the end, the  value undef is returned to signal that there is no more records in the file. Similarly functions can signal that  there is no more values by returning the undef  value.

Here is how defined if described in Perl documentation (perlfun):

Returns a Boolean value telling whether EXPR has a value other than the undefined value undef. If EXPR is not present, $_ will be checked.

Many operations return undef to indicate failure, end of file, system error, uninitialized variable, and other exceptional conditions. This function allows you to distinguish undef from other values. (A simple Boolean test will not distinguish among undef, zero, the empty string, and "0", which are all equally false.) Note that since undef is a valid scalar, its presence doesn't necessarily indicate an exceptional condition: pop() returns undef when its argument is an empty array, or when the element to return happens to be undef.

You may also use defined() to check whether a subroutine exists, by saying defined &func without parentheses. On the other hand, use of defined() upon aggregates (hashes and arrays) is not guaranteed to produce intuitive results, and should probably be avoided.

When used on a hash element, it tells you whether the value is defined, not whether the key exists in the hash. Use exists for the latter purpose.

Operations of scalar variables

(to be written)

Second Look on Arrays

Arrays allow to access to their elements by number. Array in Perl are quite different from arrays in C and are more like a buffer of a text editor with indexes as line numbers. There are two notation for arrays -- regular index notation and so called list notation. For example (1,2,3) is an array with three elements.

Like in C and unlike any text editor the first element of array has index zero. For example the first element of array @mybuffer is $mybuffer[0], the second element is $mybuffer[1], and so on. 

You can initialize arrays using list notation:

@x=(1,2,3) # now @x contains three elements $x[0], $x[1] and $x[2]

Negative indexes does not make sense in Perl arrays, but they are used to denote access to the end of the array, not from the start. The last element is $mybuffer[-1], the element before last is $mybuffer[-2], etc. This is quite convenient shortcut worth remembering.

Again, arrays in Perl are much more like lists (or buffers of  text editors which are essentially lists) -- they have no lower or upper bound and can accept any type of variable (both numbers and strings). All array names are prefixed by an @ symbol, but elements are prefixed with $. For example:

@workweek  = ("Mn", "Ts", "Wn", "Th","Fr"); # initialization of array @workweek with 5 values
@weekend = ("St", "Sn");

Like in C the array is accessed by using indices starting from 0, and square brackets are used to specify the index. For example:

print $workweek[4]; # will print Fr. Notice symbol $ instead of @

This substitution of  @ with $ is a frequent source of errors for beginners. Be careful. In this particular case there is some logic in this convention (after all each element of array is a scalar) and  you need to adapt to it.

If index is non-numeric that 0 will used. So the following two statements are equal:

$color["abba"]="blue";
$color[0]="blue";  # same as above

Slices

Unlike C it is possible to specify multiple indexes. This is called a array slice or simply slice. For example

@x[1,2]=(3,4) # slice of array @x with indexes 1 and 2 is assigned values 3 and 4

Any slice in scalar context returns the last element of the slice, not the number of elements like an array. So

$s=@x[0]; # wrong way to assign $x[0] to a veriable $s

Slices accept Pascal range notation (..). for example

@x[2..5]=(1,2,3,4);

@danger_levels[1..3]=('green','orange','red');

Arrays on the left side of assignment statement are evaluated before any operations on right side. That's mean that in Perl you can exchange two elements using:

($a,$b)=($b, $a);

Undef and arrays

Only uninitialized scalar variables in Perl have the undef value. Uninitialized arrays have the value of the empty list (). You can assign undef value to array and pretty logically it destroys the content of the array and free all the memory.  The same effect can be achieved by assigning the array an empty list and this is a more common notation.

You cannot shorten array or remove elements from array by assigning undef value to them. This not very logical but that's how it is.  So here undef is a special value, not just the fact of absence of identifier in the symbol table like it the logical view on undef for scalars presuppose.

Operation on arrays

Arrays are classical data structure. So operations on arrays will be discussed in more details in the next chapter.

Second Look on Hashes
(Associative Arrays)

Associative arrays or hashes are a generalization of a regular arrays to a non numeric indexes.  They provide a built in search capability. You put values into the hash by defining key-value pairs. Like Perl arrays, hashes grow and shrink automatically when you add or subtract elements. The main difference is that array indexes are converted to numeric before retrieving the value and in associative arrays they are converted to string and are usually arbitrary strings (for regular arrays all non-numeric indexes are equivalent to the index 0). 

The second important difference is that associative array entries are not created on mere reference, like scalars.

To define an associative array we use the usual parenthesis notation, but the array itself is prefixed by a % sign. Suppose we want to create an array of url of sites and there IP addresses. It would look like this:

%ip =( "www.yahoo.com", "204.71.200.68",  # note brackets "(" and ")"
       "www.google.com",   "209.185.108.220", 
       "www.northenlight.com",   "128.11.1.1", 
     );

As a cosmetic improvement we can replace ",' with "=>". this way it's easier to count pairs so it is a recommended notation in all cases where Perl script is written by human (in generated scripts notation above is simpler and can be  preferable):

%ip = ( "www.yahoo.com" => "204.71.200.68", 
        "www.google.com" =>   "209.185.108.220", 
        "www.northenlight.com" => "128.11.1.1", 
      );

$ip{"www.yahoo.com"};		# Returns 204.71.200.68
$ip{"www.northenlight.com"};	# Returns 128.11.1.1

An associative array can be converted back into a list array just by assigning it to a list array variable. Order of variable is underemined in this conversion. A list array can be converted into an associative array by assigning it to an associative array variable. each pair will be converted into one hash element. Logically the list array should have an even number of elements, but if not the value of the last will be undef. 

@info = %ip;		# @info is a list array. It
			# now has 6 elements, but the order of pairs may changed
%ip=@info;		# Reverse operation

If you wish to access a value, you can say:

Again note that one needs to use prefix $ instead of %. To change the value you can also say:

Hashes are not lists, so there is no previous and next element related operations defined on hashes. If you try to get all of them, then the order in which Perl will extract values is undetermined and can be different from the order in which you put elements into the hash.

You can delete a single element of hash with the operator delete, for example:

            delete $ip{'www.yahoo.com'};

Undef and hashes

Like arrays the initial value of hash is an associative array with no elements. So if you convert such hash to an array you will receive an empty list. Built-in function undef is applicable to hashes and will convert any hash to an empty one. As you will see in the next chapter you need to apply a special built-in function delete to remove element from the hash.

Operation on Hashes

Hashes are non-traditional data structure and here Perl is a to certain extent a pioneer. We will discuss operations on hashes in more details in the next chapter.

Implementing read-only variables via "use constant"  contruct

Perl provides a facility for creating constant values, via the "use constant" pragma. use constant works for scalars and arrays, not hashes.

• The constants created have no leading $ or @ character.
• These constants are global for the package in which they're declared, but be overridden (bad practice):

   use constant PI => 3.14159;

   ...
   use constant PI => 2.71828;

• These constants cannot be interpolated into strings.
• Syntax is sometimes tricky:

   use constant CARRAY => (2, 3, 5, 7, 11, 13);
   $a_prime = CARRAY[2];        # wrong!
   $a_prime = (CARRAY)[2];      # right -- MUST use parentheses

• You have to be very careful in places where barewords are allowed (hashes). For example:

   use constant SOME_KEY => 'key';
   %hash = (key => 'value', other_key => 'other_value');
   $some_value = $hash{SOME_KEY};        # wrong!
   $some_value = $hash{+SOME_KEY};       # right

  (who thinks to use a unary plus when using a hash?)

Using typeglob constacts are read-variable

Another way to create read-only scalars is to modify the symbol table entry for the variable by using a typeglob:

 *a = \'value';

This works fine, but it only works for global variables ("my" variables have no symbol table entry). Also, the following similar constructs do not work:

 *a = [1, 2, 3];      # Does NOT create a read-only array
 *a = { a => 'A'};    # Does NOT create a read-only hash

There is also Readonly.pm  but it imposes a performance penalty. In other words it's pretty slow and pretty complex.  Not recommended.  I think that this feature should be implemented on the language level not via crutches.

Prev | Up | Contents | Down | Next