CPTG286K Programming - Perl

Chapter 3: Arrays and List Data

Lists and Arrays

• A list is ordered scalar data

• An array variable holds a list

• Each array element is a scalar variable with an independent and ordered scalar value

• PERL arrays can have no elements, or can fill up to all of available memory

Literal Representation

• An empty list is represented by an empty pair of parentheses: ()

• Non-empty lists contain comma-separated values enclosed in parentheses:

(1,2,3) # array of 1, 2, and 3

(“fred”, 4.5) # array of “fred” and 4.5

• List elements may contain expressions:($a,17) # current value of $a and 17

($b+$c,$d+$e) # two values from 4 variables

List Constructor Operator

• A list constructor operator creates a list of values

• List literals that contain two scalar values separated by two consecutive periods create a list of values

• Values start at left scalar value through the right scalar value, incrementing by one

Examples of List Constructor Operators

(1..5) # same as (1, 2, 3, 4, 5)

(1.2 .. 5.2) # same as (1, 2, 3, 4, 5)

(1.3 .. 6.1) # same as (1, 2, 3, 4, 5, 6)

(2..6,10,12) # same as (2,3,4,5,6,10,12)

($a..$b) # range determined by $a, $b

# if $a > $b then empty list ()

(5..1) # same as ()

print (“The answer is ”,@a,“\n”);

# function print’s list literal

Array Variables

• Array variables hold a single list value

• Variable names for arrays are similar to those for scalars, except they start with a @ rather than a $

• The value of an un-assigned array variable is (), the empty list

• @fred is NOT related to $fred

Assigning Values Into Arrays

• Use the equal sign = to assign values into array variables

• Array variable names may appear in a list of literals (not same as list of lists); variable names are replaced by their current values

• If a scalar value is assigned to an array variable, the value becomes the single element of an array

Examples of Assigning Arrays

@fred = (1,2,3); # @fred is (1,2,3)

@barney = @fred; # Copied to barney array

@huh = 1; # Scalar 1 is single # element value of huh

@fred = qw(one two); # @fred is (“one”,“two”)

@barney = (4,5,@fred,6,7) # barney becomes

# (4,5,“one”,“two”,6,7)

@barney = (8,@barney); # (8,4,5,“one”,“two”,6,7)

@barney = (@barney,“last”);

# (8,4,5,“one”,“two”,6,7,“last”)

Variable References

• If a list literal contains only variable references such as ($a, $b, $c), rather than expressions such as ($a+$b, $c-1, $d*$z), the references can be treated as variables

• If number of elements does not match number of variables, excess values on the right side of equal sign are discarded; excess variables are assigned undef

Intro to Scalar and Array Context

• Scalar context: a scalar variable is assigned an array variable. The scalar variable yields the array’s length:

@fred = (4,5,6); # Initialize @fred

$a = @fred; # $a gets 3, the length of @fred

• Array (or list) context: an array variable receives another array variable:

($a) = @fred; # $a gets first element of @fred

Examples of Variable References

($a,$b,$c) = (1,2,3); # assign 1,2,3 to $a, $b, $c($a,$b) = ($b,$a); # swap with no tmp

variable!($d,@fred) = ($a,$b,$c); # $d = $a, @fred = ($b,$c)($e,@fred) = @fred; # Remove @fred[0] to $e, so

# $e = $b, @fred = ($c)

• Note: Place the array variable at the end of the list, because it may contain an undetermined number of values

@fred) = (4,5,6); # Initialize @fred$a = @fred; # scalar context: $a on left

# $a gets 3, length of @fred($a) = @fred; # array context: ($a) on left

# $a gets first element of @fred

Array Element Access

• Elements are accessed as scalar variables; the first element of @fred is accessed as $fred[0]

• A negative subscript counts elements from the end: -1 is last element, second to last is -2, etc.

• $#array_name yields the index value of the last element in @array_name

Array Element Access Examples

@fred = (7,8,9); # Initialize @fred

$a = 2;

$b = $fred[0]; # $b is 7

$b = $fred[$a]; # same as $fred[2], $b is now

$fred[0] = 5; # @fred = (5,8,9);

$c = $fred[1]; # $c is 8

$fred[2]++; # increment third element

$fred[1] += 4; # add 4 to second element

($fred[0],$fred[1]) = ($fred[1],$fred[0]);

# swap the first two elements

@fred = (“fred”, “wilma”, “pebbles”, “dino”);

print $fred[-1]; # prints “dino”

print $#fred; # prints 3

print $fred[$#fred]; # prints “dino” too

Array Element Access Using A

Slice access

• Use the @ prefix instead of $, because you’re accessing a part of an array, which is more than just one scalar element

@fred[0,1]; # same as ($fred[0],$fred[1])@fred[0,1] = @fred[1,0]; # swap first two elements@fred[0,1,2] = @fred[1,1,1];

# make all 3 elements like the second@fred[1,2] = (9,10);

# change last two values to 9 and 10$a = 2; # set $a to 2

($c) = (7,8,9)[$a-1]; # $c = 8

Examples of Slice Access

@fred[0,1]; # or ($fred[0],$fred[1])

@fred[0,1] = @fred[1,0]; # swap first two elements

@fred[0,1,2] = @fred[1,1,1];

# make all 3 elements like the second

@fred[1,2] = (9,10); # change last two values

# to 9 and 10

@fred = (7,8,9); # Initialize @fred

($c) = (7,8,9)[$a-1]; # same as $fred[1], $c = 8

@barney = (2,1,0); # Setup subscript array

@backfred = @fred[@barney];

# yields @fred[2,1,0], or (9,8,7)

Out of range access

• Assigning a value beyond the end of array, automatically extends it and assigns undef to existing intermediate values

@fred = (1,2,3,“hi”); # Initialize @fred

$fred[6] = “ho”; # @fred is

#(1,2,3,“hi”, undef, undef, “ho”)

• An undef value is returned for array elements accessed beyond the end of array

@barney = $fred[7]; # $barney is undef

Push and Unshift functions

• The push function adds elements to the end of the list; the unshift function adds elements to the beginning of the list

@somelist = (8,’eight’,9,’nine’);

@tenlist = (10,’ten’);

push(@somelist, @tenlist);# @somelist is now

# (8,’eight’,9,’nine’,10,’ten’);

unshift(@somelist,’The Big Seven’);

# (‘The Big Seven’,8,’eight’,9,’nine’,10,’ten’);

Pop and Shift functions

• The pop function removes elements from the end of list; the shift function removes elements from the beginning of list

@somelist = (8,’eight’,9,’nine’,10);

pop (@somelist); # @somelist is now

# (8,’eight’,9,’nine’);

$removed = shift (@somelist);

# $removed = 8

# #somelist is now

# (’eight’,9,’nine’);

Reverse function

• The reverse function reverses the order of elements in the list

@a = (7,8,9); # Initialize @a

@b = reverse(@a); # @b is (9,8,7)

# @a is unchanged

• The argument list is unaltered by the function unless it is assigned to the same variable

@b = reverse(@b); # @b is reverse of itself

Sort function

• The sort function sorts its arguments as single strings in ascending ASCII order

• A sorted list is returned without altering the original list

@x = sort(“small”, “medium”, “large”);

# @x is “large”, “medium”, “small”

@y = (1,2,4,8,16,32,64);

@y = sort(@y);# performs ASCII sort

# @y is 1,16,2,32,4,64,8

Chomp and STDIN in list context

• The chomp function also works on array variables to remove the newline character from each array element

@stuff = (“hello\n”,”world\n”,”happy days”);

chomp(@stuff);

# @stuff is now (“hello”,”world”,”happy days”)

• <STDIN> in list context can read remaining lines up to end of file

@a = <STDIN>; # read until EOF, or CTRL-D (Z)

Variable Interpolation in Arrays

• Arrays may be interpolated into double-quoted strings

• Use the curly bracket delimitter to distinguish scalar variable placed next to square brackets, from array variables

• Portions of an array can be interpolated by using slices

Examples of Array Interpolation

@fred = (“hello”, “dolly”);

$y = 2;

$x = “This is $fred[$y-1]’s place”;

# This is dolly’s place

$fred = “right”;

$y = “This is $fred[1]”; # $y=“This is dolly”

$y = “This is ${fred}[1]”; # “This is right[1]”

@fred = (“a”,”bb”,”ccc”,1,2,3);

@all = “Now for @fred[2,3] here!”;

# $all gets “Now for ccc 1 here!”

@all = “Now for @fred[@fred[4,5]] here!”; # same