Difference between revisions of "Perl/Basics/Variables and Data Types"

Latest revision as of 02:02, 19 July 2012

In strict perl, variables must be declared using the "my" or "our" operators. "my" is used implicitly in non-shared memory, whereas "our" is used explicitly for shared memory to pass data between threads.

Scalars

Scalars in perl are prefixed with a $. A scalar may contain any string, integer, or floating point value. It may also contain a reference pointer. An example declaration:

Arrays

Arrays (or lists) have elements. Typically an array in perl can contain anything - each element can be something different. An array element may be a hash, hash reference, scalar, or another array.

Arrays are prefixed by the @ character:

You can access and modify array elements directly:

Helper Functions

join()

Join will compile an array into a scalar. Using the array example above, @messages, the following code will generate the string "Hello world!\n, I like perl!\n" as a scalar:

split()

Split takes a scalar and converts it to an array using a delimiter. Using our string from earlier:

push()

The push() function is used to append an element or elements to the end of an array, similar to the push instruction in assembly and treats the array like a stack.

 
my @array;
push(@array,'element one');
push(@array,('element two','element three'));
 

$array[$#array] = "new element";

pop()

The pop() function is similar to the pop instruction in assembly and treats the array like a stack.

my @array;
$array[$#array] = 1;
$popped = pop(@array);
 

The same affect can be acheived with:

$popped = $array[$#array--];

Executing pop() on an array will delete the highest order array element.

unshift()

The unshift() function is like the inverse of the push() function and treats the array like a stack. In stead of pushing to the top of the stack, this function operates against the bottom of the stack.

my @array;
$array[0] = 1;
unshift(@array,0); # $array[0] now contains "0" and $array[1] now contains [1].
 

shift()

The shift() function is like the inverse of the pop() function and treats the array like a stack. In stead of popping from the top of the stack, this function operates against the bottom of the stack.

my @array = (0,1);
my $first_element = shift(@array); # $array[0] now contains one, and @array only contains one element
 

Hashes

A hash is very similar to a struct in C.

Introduction

Hashes are prefixed by the % character. Hash element values are prefixed by $. A hash element may contain another hash, an array, or a scalar.

• You can directly modify the key inside of a hash

• You can also create a key => value pair on declaration

• Example:

Helper Functions

each()

"while my each" can be used to isolate $key => $value pairs from a hash as follows with our %user hash:

keys

This uses a foreach() loop and casting. We can isolate $key=>$value pairs the same as above using keys in stead of each:

References

A reference is very similar to a pointer in C.

Hash References

A hash reference is a scalar created using the \ operator as follows:

 
my %user;
$user{'name'}    = "hatter";
$user{'network'} = "irc.blackhatacademy.org";
 
my $hashref = \%user;
 

Once you've created a hashref (hash reference) you must use pointers to access a key:

 
print $user->{'name'} . "\n";
print $user->{'network'} . "\n";
 

Callback References

This involves user-defined functions. User-defined functions are covered later in this article. A callback reference is a scalar that points to a function. To create a callback reference:

my $callback = \&function_name;
 

To execute the callback function and pass it arguments:

$callback->($arg1, $arg2);

Casting

Casting is the process of transitioning from one data type to another. This is typically done using curly brackets {} preceeded by a data type designator ($,%, or @).

• To cast a hash reference back to a hash:

 
my %hash;
my $hashref = \%hash; #create the hash reference
 
my %casted  = %{$hashref}; #Cast back to a hash.
 

• To cast a list of keys in a hash into an array:

 
my @casted = @{keys %hash};
 

• To cast a scalar value to an integer:

 
my $integer = int($scalar);