(1, 5.3, "hello", 2)

(1, 5.3, $var)                 # once the element has been assigned the value of $var it remains this
                               # value even if you change $var

( 1, $var1 + $var2)            # 2nd element becomes the value of $var1 + $var2

(1, "This is string", 3)       # you can even use strings as values

@array = (1, 2, 3, 4, 5);      # here the array variable array contains the list 1, 2, 3, 4, and 5

Note: when the perl interpreter sees a @(at) sign it knows that it is an array.          

$scalar = $array[0];           # The first element in the array
$scalar = $array[5];           # The 6th element in the array (remember its starts at zero)

$scalar = $array[$index];      # you can use the value of a variable to access the elements

@food = qw(apple banana orange lemon melon peach plum);   # array food will contain 7 elements (0-6)

$count = 1;
while ($count <= 7)
{
   print ("element $count is $food[$count-1]\n");         # using value of a variable to get element
   $count++;
}

@array = qw(1 2 3 4 5 6 7 8 9 10);       # The old way   

@array = qw(1 .. 10);                    # the simpler way
@array = qw(2, 5 .. 7, 8);               # array contains 2, 5, 6, 7 and 8

@array = qw(3..3);                       # will contain one element 3

@array = qw($var1+10 .. $var2+100);      # can use complex expressions to create list ranges

@days_of_month("01".."31");              # list contains days of the month (including leading zeros)

@array = qw( 1 @list 3);                 # you can even use other arrays to populate arrays

@food = qw(apple banana orange lemon melon peach plum);

@food_allergies = @food;

while ($count <= 15)
{
   print ("I would be very sick if i ate the following food $food_allergies[$count-1]\n");
   $count++;
}

@burgers = ("Big Mac's", "Whopper's");

($mcdonalds, $burger_king) = @burgers;         # assign the array elements to the scalar variables

print("Mcdonalds have $mcdonalds\n");
print("Burger King have $burger_king\n");

($dummy1, $dummy2, $dummy3) = @burgers;        # $dummy3 will have null assigned as not enough elements

@food = qw(apple banana orange lemon melon peach plum);

$number_of_food_elements = @food;              # get the number of elements in array food
print ("There are $number_of_food_elements elements in array food\n");

$count = 1;
## Use the scalar variable for the element value
while ($count <= $number_of_food_elements)     # use the number of elements in the while loop (could use
{                                              # @food as well)
   print ("$food[$count-1]\n");
   $count++;
}

## Use the array itself to get the number of elements
while ($count <= @food)                        # same effect as above
{                                              
   print ("$food[$count-1]\n");
   $count++;
}

@food[@food .. @food+3] = qw(pineapple strawberry blackberry raspberry); #add to array food

$count = 1;
while ($count <= @food)
{
   print ("$food[$count-1]\n");
   $count++;
}

@food[1,2,3] = @food[4,5,6];    # we overwrite existing elements using same array food

$count = 1;
while ($count <= @food)
{
  print ("$food[$count-1]\n");
  $count++;
}

$count = 1;
while ($count <= @input_file)
{
   print ("$input_file[$count-1]\n");
   $count++;
}

@array = ("this", "is", "a", "test");

@array2 = sort (@array);                # array2 will contain ("a", "is", "test", "this");

@num = (70, 100, 8);
@num2 = sort (@num);                    # num2 will contain ( 100, 70, 8 ) not (8, 70, 100) - see below

Note: sort treats numbers as strings

@array = ("backwards", "is", "array", "this");

@array2 = reverse @array;               # array2 will contain ("this", "array", "is", "backwards");

@list = ("here, "is", "a");

$string = join (" ", @list, "String");  # $string will contain " here is a String", whitespace is the join character                    
$string = join ("::", @list, "String"); # $string will contain "::here::is::a::String" :: is the join character

Note: the first argument to join is the join character   

$fruit{"bananas"} = 1;
$number{3.14159};
$integer{-7};
$fruit{$my_fruit};

Note: using the dollar sign ($) tells the perl interpreter that this is a single scalar item and is to be treated as such

%associative_array;                          # declare an associative array
%array = ("foo", "26", "bar", "27");         # declare and populate an associative array

$fruit{"bananas"} = 1;
$fruit{"apples"} = 3;
foreach $item (sort keys (%fruit)) {
   print $item . " = " . $fruit{$item} . "\n";
}

Note: There is no order within the array, elements can be all over the place

delete($fruit{"bananas"});

Note: delete is the only way to delete from an associative array

%array = ("foo", "26", "bar", "27");
@keys = keys(%array);
print("@keys\n");

# keys is commonly used as below
foreach $i (keys (%array)) {
   print $i . "\n";
}

Note: in no particular order will the list be returned

foreach $i (values (%array)) {
   print $i . "\n";
}

Note: in no particular order will the list be returned

%valle = ("Paul", 35, "Lorraine", "31", "Dominic", 12, "Jessica", 8);

## Using the foreach loop
foreach $i (keys (%valle)) {
   print $i . " " . $valle{$i} . "\n";
}

# Using a while loop
while (($name, $age) = each(%valle)) {
   print $name . " " . $age . "\n";
   ## delete $valle{"Paul"};               ## Do not use delete as it makes each unpredictable
}

Note: do not use delete when using each, because the behavior of each unpredictable

sub add_word_to_list {
   local($word) = @_;
   local($pointer);

   # if list is empty, add first item
   if ($header eq "") {
      $header = $word;
      $wordlist{$word} = "";
      return;
   }

   # if word identical to first element in list, do nothing
   return if ($header eq $word);

   # see whether word should be the new first word in the list
   if ($header gt $word) {
      $wordlist{$word} = $header;
      $header = $word;
      return;
   }

   # find place where word belongs
   $pointer = $header;
   while ($wordlist{$pointer} ne "" && $wordlist{$pointer} lt $word) {
      $pointer = $wordlist{$pointer};
   }

   # if word already seen, do nothing
   return if ($word eq $wordlist{$pointer});
   $wordlist{$word} = $wordlist{$pointer};
   $wordlist{$pointer} = $word;
}

sub print_list {
   local ($pointer);

   print ("Words in this file:\n");
   $pointer = $header;
   while ($pointer ne "") {
      print ("$pointer\n");
      $pointer = $wordlist{$pointer};
   }
}

# C Structure
struct {
   int field1;
   int field2;
   int field3;
} mystructure;

# Perl Simulated structure
%mystructure = ( "field1", "",
                 "field2", "",
                 "field3", "");

sub print_tree {
   local ($nodename) = @_;
   local ($leftchildname, $rightchildname);

   $leftchildname = $nodename . "left";
   $rightchildname = $nodename . "right";
   if ($tree{$leftchildname} ne "") {
      &print_tree($tree{$leftchildname});
   }
   print ("$nodename\n");
   if ($tree{$rightchildname} ne "") {
      &print_tree($tree{$rightchildname});
   }
}

$calculator
11 + 5 * (4 - 3)
^D

Should result in 16

# grep (<pattern>, <searchlist>)

$line = "This line of input contains 8, 11 and 26.";
@words = split(/\s+/, $line);

@numbers = grep(/^\d+[.,;:]?$/, @words);
print ("Numbers: @numbers");

Note: you can also use grep with the file-test operators

opendir(CURRDIR, ".") || die("Can't open current directory");
@filelist = grep(!/^\./, grep(-r, readdir(CURRDIR)));
print ("@filelist");

# retval = splice(<array>, <skipelements>, <length>, <newlist>);

# Replace
@array = qw(1 2 3 4);
splice (@array, 1, 2, ("two", "three"));        # list will now be (1 two three 4);

# Appending
splice(@array, 3, 0, "hello", "there");         # add to position 3 shifting anythnig after
splice(@array, @array, 0, "hello", "there");    # add to the end of the list

# Deleting
splice(@array, 2, 2);                           # delete two elements from the offset

## add or delete from the left side of the array, element 0

@array = qw(1 2 3 4);

$first_element = shift(@array);

print ("Array: @array");
print("\nFirst element:" . $first_element);

unshift(@array, $first_element);
print ("\nArray: @array");

## add or delete from the right side of the array, last element

@array = qw(1 2 3 4);

$first_element = pop(@array);

print ("Array: @array");
print("\nFirst element:" . $first_element);

push(@array, $first_element);
print ("\nArray: @array");

$string = "one::two::three::four::five::six";
@words = split(/::/, $string);
@limit_words = split(/::/, $string, 3);         # specify a maximum number of elements
print ("@words");
print ("@limit_words");

@sorted = sort(@array);
print ("@sorted\n");

@reversed = reverse(@array);
print("@reversed");

@results = map($_+1, @array);

print("@results");

sub mysub {
   if (wantarray()) {
      print("Returning type is an array - TRUE\n");
   } else {
      print("Returning type is an scalar - FALSE\n");
   }
}

%array = ("foo", "26", "bar", "27");
@keys = keys(%array);
print("@keys\n");

# keys is commonly used as below
foreach $i (keys (%array)) {
   print $i . "\n";
}

Note: in no particular order will the list be returned

foreach $i (values (%array)) {
   print $i . "\n";
}

Note: in no particular order will the list be returned

foreach $i (each (%array)) {
   print $i . "\n";
}

Note: in no particular order will the list be returned, also do not use delete when using each, because the behavior of each unpredictable

$retval = delete($array{"foo"});        # returns the deleted elements value 26

foreach $i (keys (%array)) {
   print $i . "\n";                     # only bar should exist
}

print $retval;         

if ( exists($array{"foo"}) ) {
   print("Foo exists");
} else {
   print ("Foo does NOT exists");
}