Open In App

Perl | Arrays

Last Updated : 26 Nov, 2019
Like Article

In Perl, array is a special type of variable. The array is used to store the list of values and each object of the list is termed as an element. Elements can either be a number, string, or any type of scalar data including another variable.

@number = (50, 70, 46);             
@names = ("Geeks", "For", "Geeks");

Array Creation: In Perl programming every array variable is declared using “@” sign before the variable’s name. A single array can also store elements of multiple datatypes. For Example:

# Define an array
@arr = (1, 2, 3);
@arr = (1, 2, 3, "Hello");

Array creation using qw function:
qw() function is the easiest way to create an array of single-quoted words. It takes an expression as an input and extracts the words separated by a whitespace and then returns a list of those words. The best thing is that the expression can be surrounded by any delimiter like- () ” [] {} // etc. However () and // are used generally.


qw (Expression)
qw /Expression/
qw 'Expression'
qw {Expression}

Example :

# Perl program to demonstrate qw function
# using qw function
@arr1 = qw /This is a Perl Tutorial by GeeksforGeeks/;
# Creates array2 with elements at
# index 2,3,4 in array1
@arr2 = @arr1[2,3,4]; 
print "Elements of arr1 are:\n";
foreach $ele (@arr1)
    print "$ele \n";
print "Elements of arr2 are:\n";
foreach $ele (@arr2)
     print "$ele \n";


Elements of arr1 are:
Elements of arr2 are:

Accessing Array Elements: For accessing the elements of an array we must prefix “$” sign before the array variable name followed by the index in square brackets. For Example:

# Define an array
@arr = (1, 2, 3);

# Accessing and printing first 
# element of an array
print "$arr[0]\n";

# Accessing and printing second
# element of an array
print "$arr[1]\n";


# Perl program to demonstrate Array's
# creation and accessing the array's elements
# Creation an array fruits
@fruits = ("apple", "banana", "pineapple", "kiwi");
# printing the array
print "@fruits\n";
# Prints the array's elements
# one by one using index
print "$fruits[0]\n";
print "$fruits[1]\n";
print "$fruits[2]\n";
print "$fruits[3]\n";


apple banana pineapple kiwi

Note: Array indices always start from zero. To access the first element it must to give 0 as indices. We can also give a negative index. But giving negative index will result in selecting the array elements from ending not from the beginning.


# Perl program to demonstrate 
# negative index of array
# Creation an array fruits
@fruits = ("apple", "banana", "pineapple", "kiwi");
# Prints the array's elements
# one by one using negative index
print "$fruits[-1]\n";
print "$fruits[-2]\n";



Sequential Number Arrays: Perl also provides a shortcut to make a sequential array of numbers or letters. It makes out the user’s task easy. Using sequential number arrays users can skip out loops and typing each element when counting to 1000 or letters A to Z etc.


@array = (1..9); # array with numbers from 1 to 9
@array = (a..h); # array with letters from a to h


# Perl program to demonstrate
# Sequential Number Arrays
# Sequential Number Arrays for 
# numbers and letters
@nums = (1..9);
@letters = (a..h);
# Prints array- nums
print "@nums\n"
# Prints array- letters
print "@letters\n";  


1 2 3 4 5 6 7 8 9
a b c d e f g h

Size of an Array: The size of an array(physical size of the array) can be found by evaluating the array in scalar context. The returned value will be the number of elements in the array. An array can be evaluated in scalar context using two ways:

  1. Implicit Scalar Context
    $size = @array;
  2. Explicit scalar context using keyword scalar
    $size = scalar @array;

Both ways will produce the same output so it is preferred to use an implicit scalar context.


# Perl program to demonstrate 
# the length of an array
# declaring an array
@arr = (11, 22, 33, 44, 55, 66);
# Storing the length of array 
# in variable imp_size
# implicit scalar context
$imp_size = @arr;
# Storing the length of array
# in variable exp_size
# explicit scalar context
$exp_size = scalar @arr;
print "Size of arr(imp_size) $imp_size\n";
print "Size of arr(exp_size) $exp_size";


Size of arr(imp_size) 6
Size of arr(exp_size) 6

Note: In Perl arrays, the size of an array is always equal to (maximum_index + 1) i.e.

size = maximum_index + 1

And you can find the maximum index of array by using $#array. So @array and scalar @array is always used to find the size of an array.


# Perl program to find size and 
# maximum index of an array
# Array declaration and 
# assigning values to it
@arr = (10, 17, 19, 20, 25);
# to find size of array
$size_of_array = @arr;
# to find Maximum index of array
$maximum_index = $#arr;
# displaying result
print "Maximum Index of the Array: $maximum_index\n";
print "The Size of the Array:  $size_of_array\n";


Maximum Index of the Array: 4
The Size of the Array:  5

Iterating through an Array: We can iterate in an array using two ways:

  • Iterating through the range: We can iterate through the range by finding the size of an array and then running a for loop from 0 to the size – 1 and then accessing the elements of the array.


    # Perl program to illustrate 
    # iteration through range
    # array creation
    @arr = (11, 22, 33, 44, 55);
    # size of array
    $len = @arr;
    for ($b = 0; $b < $len; $b = $b + 1)
        print "\@arr[$b] = $arr[$b]\n";



    @arr[0] = 11
    @arr[1] = 22
    @arr[2] = 33
    @arr[3] = 44
    @arr[4] = 55
  • Iterating through elements(foreach Loop): We can iterate through the elements using foreach loop. Using this we can directly access the elements of the array using a loop instead of running a loop over its range and then accessing the elements.


    # Perl program to illustrate Iterating 
    # through elements(foreach Loop)
    # creating array
    @l = (11, 22, 33, 44, 55);
    # foreach loop
    foreach $a (@l)
          print "$a ";



    11 22 33 44 55

Like Article
Suggest improvement
Share your thoughts in the comments

Similar Reads