Home » Perl Array

Summary : in this tutorial, you’ll learn about Perl array and how to use arrays effectively in your program.

Introduction to Perl array

Perl Array

A list is immutable so you cannot change it directly. In order to change a list, you need to store it in an array  variable .

By definition, an array is a variable that provides dynamic storage for a list.

In Perl, the terms array and list are used interchangeably, but you have to note an important difference: a list is immutable whereas an array is mutable. In other words, you can modify the array’s elements, grow or shrink the array, but not a list.

A scalar variable begins with the dollar sign ( $ ), however, an array variable begins with an at-sign ( @ ).

The following example illustrates how to declare an array variable:

The $ sign looks like S in the word s calar. And @ looks like a in the word a rray, which is a simple trick to remember what type of variables you are working with.

Accessing Perl array elements

Like a list, you can access array elements using square brackets []  and indices as shown in the following example:

If you take a look at the code carefully, you will see that we used $days[0] instead of @days[0] .

This is because an array element is a scalar, you have to use the scalar prefix ( $ ). In Perl, the rule is that the prefix represents what you want to get, not what you’ve got.

Perl also allows you to access array elements using negative indices. Perl returns an element referred to by a negative index from the end of the array. For example, $days[-1] returns the last element of the array @days .

You can access multiple array elements at a time using the same technique as the list slice.

Counting Perl array elements

If you treat an array as a scalar, you will get the number of elements in the array. Take a look at the following code:

However, this code causes an error in case you don’t really want to count it but accidentally assign an array to a scalar. To be safe, use the scalar() function as follows:

The operator $#  returns the highest index of an array. See the following example:

Modifying Perl array elements

To change the value of an element, you access the element using the index and assign it a new value. Perl also allows you to change the values of multiple elements at a time.

See the following example:

Perl array operations

Perl provides several useful functions and operators to help you manipulate arrays effectively. We will cover the most important ones in the following sections.

Perl array as a stack with push() and pop() functions

Both functions treat an array as a stack. A stack works based on the last in first out (LIFO) philosophy. It works exactly the same as a stack of books. The push() function appends one or more elements to the end of the array, while the pop() function removes the last element from the end of the array.

The following example demonstrates how to use push() and pop() functions:

Perl array as a queue with unshift() and pop() functions

If the push() and pop() treat an array as a stack, the unshift() and pop() functions treat an array as a queue. A queue works based on the first in first out (FIFO) philosophy. It works like a queue of visitors. The unshift() function adds one or more elements to the front of the array, while the pop() function removes the last element of the array.

The following example demonstrates how to use the unshift() and pop() functions:

Sorting Perl arrays

Perl provides the sort() function that allows you to sort an array in alphabetical or numerical order. Here is an example of sorting an array of strings alphabetically.

The sort() function also accepts a block of code that allows you to change the sort algorithm. If you want to sort an array in numerical order, you need to change the default sorting algorithm.

Let’s take a look at the example below:

In the example above:

  • First, we had an unsorted array @a , and we displayed the @a array to make sure that it is unsorted.
  • Second, we used the sort() function to sort the @a array. We passed a block of code {$a <=>$b} and the @a array to the sort function. The $a  and $b are global variables defined by the sort() function for sorting. The operator <=> is used to compare two numbers. The code block {$a <=> $b} returns -1 if $a < $b , 0 if $a = $b , and 1 if $a > $b .
  • Third, we displayed the elements of the sorted array @a.

For more information on the sort()  function, check out the Perl sort function .

In this tutorial, we’ve introduced you to Perl array and shown you some useful techniques to manipulate array’s elements effectively.

Back to Seekers of Perl Wisdom

www . com | www . net | www . org

  • GrandFather
  • Seekers of Perl Wisdom
  • Cool Uses for Perl
  • Meditations
  • PerlMonks Discussion
  • Categorized Q&A
  • Obfuscated Code
  • Perl Poetry
  • PerlMonks FAQ
  • Guide to the Monastery
  • What's New at PerlMonks
  • Voting/Experience System
  • Other Info Sources
  • Nodes You Wrote
  • Super Search
  • List Nodes By Users
  • Newest Nodes
  • Recently Active Threads
  • Selected Best Nodes
  • Worst Nodes
  • Saints in our Book
  • The St. Larry Wall Shrine
  • Offering Plate
  • Random Node
  • [id://781756|Buy PerlMonks Gear]
  • [Snippets Section|Snippets]
  • [Code Catacombs]
  • [Editor Requests]
  • blogs.perl.org
  • [http://planet.perl.org/|Planet Perl]
  • [http://ironman.enlightenedperl.org/|Perl Ironman Blog]
  • Perl Weekly
  • Perl Mongers
  • Perl Directory
  • Perl documentation
  • Today I Learned

Taking a day trip Baking Proposing Leaping Reading La_Bougie_du_Sapeur Making love, not war Enjoying life Relaxing (as there is no leap year bug in my code) Playing Frog Out Other

Results (21 votes) . Check out past polls .

  • Backslash Operator
  • Square Brackets
  • Curly Brackets
  • Anonymous Subroutines
  • Constructors
  • Autovivification
  • Typeglob Slots
  • Simple Scalar
  • Arrow Notation
  • Miscellaneous Usage
  • Circular References
  • Symbolic references
  • Not-so-symbolic references
  • Pseudo-hashes: Using an array as a hash
  • Function Templates
  • Postfix Dereference Syntax
  • Postfix Reference Slicing
  • Assigning to References
  • Declaring a Reference to a Variable
  • WARNING: Don't use references as hash keys

perlref - Perl references and nested data structures

This is complete documentation about all aspects of references. For a shorter, tutorial introduction to just the essential features, see perlreftut .

# DESCRIPTION

Before release 5 of Perl it was difficult to represent complex data structures, because all references had to be symbolic--and even then it was difficult to refer to a variable instead of a symbol table entry. Perl now not only makes it easier to use symbolic references to variables, but also lets you have "hard" references to any piece of data or code. Any scalar may hold a hard reference. Because arrays and hashes contain scalars, you can now easily build arrays of arrays, arrays of hashes, hashes of arrays, arrays of hashes of functions, and so on.

Hard references are smart--they keep track of reference counts for you, automatically freeing the thing referred to when its reference count goes to zero. (Reference counts for values in self-referential or cyclic data structures may not go to zero without a little help; see "Circular References" for a detailed explanation.) If that thing happens to be an object, the object is destructed. See perlobj for more about objects. (In a sense, everything in Perl is an object, but we usually reserve the word for references to objects that have been officially "blessed" into a class package.)

Symbolic references are names of variables or other objects, just as a symbolic link in a Unix filesystem contains merely the name of a file. The *glob notation is something of a symbolic reference. (Symbolic references are sometimes called "soft references", but please don't call them that; references are confusing enough without useless synonyms.)

In contrast, hard references are more like hard links in a Unix file system: They are used to access an underlying object without concern for what its (other) name is. When the word "reference" is used without an adjective, as in the following paragraph, it is usually talking about a hard reference.

References are easy to use in Perl. There is just one overriding principle: in general, Perl does no implicit referencing or dereferencing. When a scalar is holding a reference, it always behaves as a simple scalar. It doesn't magically start being an array or hash or subroutine; you have to tell it explicitly to do so, by dereferencing it.

# Making References

References can be created in several ways.

# Backslash Operator

By using the backslash operator on a variable, subroutine, or value. (This works much like the & (address-of) operator in C.) This typically creates another reference to a variable, because there's already a reference to the variable in the symbol table. But the symbol table reference might go away, and you'll still have the reference that the backslash returned. Here are some examples:

It isn't possible to create a true reference to an IO handle (filehandle or dirhandle) using the backslash operator. The most you can get is a reference to a typeglob, which is actually a complete symbol table entry. But see the explanation of the *foo{THING} syntax below. However, you can still use type globs and globrefs as though they were IO handles.

# Square Brackets

A reference to an anonymous array can be created using square brackets:

Here we've created a reference to an anonymous array of three elements whose final element is itself a reference to another anonymous array of three elements. (The multidimensional syntax described later can be used to access this. For example, after the above, $arrayref->[2][1] would have the value "b".)

Taking a reference to an enumerated list is not the same as using square brackets--instead it's the same as creating a list of references!

As a special case, \(@foo) returns a list of references to the contents of @foo , not a reference to @foo itself. Likewise for %foo , except that the key references are to copies (since the keys are just strings rather than full-fledged scalars).

# Curly Brackets

A reference to an anonymous hash can be created using curly brackets:

Anonymous hash and array composers like these can be intermixed freely to produce as complicated a structure as you want. The multidimensional syntax described below works for these too. The values above are literals, but variables and expressions would work just as well, because assignment operators in Perl (even within local() or my()) are executable statements, not compile-time declarations.

Because curly brackets (braces) are used for several other things including BLOCKs, you may occasionally have to disambiguate braces at the beginning of a statement by putting a + or a return in front so that Perl realizes the opening brace isn't starting a BLOCK. The economy and mnemonic value of using curlies is deemed worth this occasional extra hassle.

For example, if you wanted a function to make a new hash and return a reference to it, you have these options:

On the other hand, if you want the other meaning, you can do this:

The leading +{ and {; always serve to disambiguate the expression to mean either the HASH reference, or the BLOCK.

# Anonymous Subroutines

A reference to an anonymous subroutine can be created by using sub without a subname:

Note the semicolon. Except for the code inside not being immediately executed, a sub {} is not so much a declaration as it is an operator, like do{} or eval{} . (However, no matter how many times you execute that particular line (unless you're in an eval("...") ), $coderef will still have a reference to the same anonymous subroutine.)

Anonymous subroutines act as closures with respect to my() variables, that is, variables lexically visible within the current scope. Closure is a notion out of the Lisp world that says if you define an anonymous function in a particular lexical context, it pretends to run in that context even when it's called outside the context.

In human terms, it's a funny way of passing arguments to a subroutine when you define it as well as when you call it. It's useful for setting up little bits of code to run later, such as callbacks. You can even do object-oriented stuff with it, though Perl already provides a different mechanism to do that--see perlobj .

You might also think of closure as a way to write a subroutine template without using eval(). Here's a small example of how closures work:

This prints

Note particularly that $x continues to refer to the value passed into newprint() despite "my $x" having gone out of scope by the time the anonymous subroutine runs. That's what a closure is all about.

This applies only to lexical variables, by the way. Dynamic variables continue to work as they have always worked. Closure is not something that most Perl programmers need trouble themselves about to begin with.

# Constructors

References are often returned by special subroutines called constructors. Perl objects are just references to a special type of object that happens to know which package it's associated with. Constructors are just special subroutines that know how to create that association. They do so by starting with an ordinary reference, and it remains an ordinary reference even while it's also being an object. Constructors are often named new() . You can call them indirectly:

But that can produce ambiguous syntax in certain cases, so it's often better to use the direct method invocation approach:

This indirect object syntax is only available when use feature "indirect" is in effect, and that is not the case when use v5.36 (or higher) is requested, it is best to avoid indirect object syntax entirely.

# Autovivification

References of the appropriate type can spring into existence if you dereference them in a context that assumes they exist. Because we haven't talked about dereferencing yet, we can't show you any examples yet.

# Typeglob Slots

A reference can be created by using a special syntax, lovingly known as the *foo{THING} syntax. *foo{THING} returns a reference to the THING slot in *foo (which is the symbol table entry which holds everything known as foo).

Most of these are self-explanatory, but *foo{IO} deserves special attention. It returns the IO handle, used for file handles ( "open" in perlfunc ), sockets ( "socket" in perlfunc and "socketpair" in perlfunc ), and directory handles ( "opendir" in perlfunc ). For compatibility with previous versions of Perl, *foo{FILEHANDLE} is a synonym for *foo{IO} , though it is discouraged, to encourage a consistent use of one name: IO. On perls between v5.8 and v5.22, it will issue a deprecation warning, but this deprecation has since been rescinded.

*foo{THING} returns undef if that particular THING hasn't been used yet, except in the case of scalars. *foo{SCALAR} returns a reference to an anonymous scalar if $foo hasn't been used yet. This might change in a future release.

*foo{NAME} and *foo{PACKAGE} are the exception, in that they return strings, rather than references. These return the package and name of the typeglob itself, rather than one that has been assigned to it. So, after *foo=*Foo::bar , *foo will become "*Foo::bar" when used as a string, but *foo{PACKAGE} and *foo{NAME} will continue to produce "main" and "foo", respectively.

*foo{IO} is an alternative to the *HANDLE mechanism given in "Typeglobs and Filehandles" in perldata for passing filehandles into or out of subroutines, or storing into larger data structures. Its disadvantage is that it won't create a new filehandle for you. Its advantage is that you have less risk of clobbering more than you want to with a typeglob assignment. (It still conflates file and directory handles, though.) However, if you assign the incoming value to a scalar instead of a typeglob as we do in the examples below, there's no risk of that happening.

# Using References

That's it for creating references. By now you're probably dying to know how to use references to get back to your long-lost data. There are several basic methods.

# Simple Scalar

Anywhere you'd put an identifier (or chain of identifiers) as part of a variable or subroutine name, you can replace the identifier with a simple scalar variable containing a reference of the correct type:

It's important to understand that we are specifically not dereferencing $arrayref[0] or $hashref{"KEY"} there. The dereference of the scalar variable happens before it does any key lookups. Anything more complicated than a simple scalar variable must use methods 2 or 3 below. However, a "simple scalar" includes an identifier that itself uses method 1 recursively. Therefore, the following prints "howdy".

Anywhere you'd put an identifier (or chain of identifiers) as part of a variable or subroutine name, you can replace the identifier with a BLOCK returning a reference of the correct type. In other words, the previous examples could be written like this:

Admittedly, it's a little silly to use the curlies in this case, but the BLOCK can contain any arbitrary expression, in particular, subscripted expressions:

Because of being able to omit the curlies for the simple case of $$x , people often make the mistake of viewing the dereferencing symbols as proper operators, and wonder about their precedence. If they were, though, you could use parentheses instead of braces. That's not the case. Consider the difference below; case 0 is a short-hand version of case 1, not case 2:

Case 2 is also deceptive in that you're accessing a variable called %hashref, not dereferencing through $hashref to the hash it's presumably referencing. That would be case 3.

# Arrow Notation

Subroutine calls and lookups of individual array elements arise often enough that it gets cumbersome to use method 2. As a form of syntactic sugar, the examples for method 2 may be written:

The left side of the arrow can be any expression returning a reference, including a previous dereference. Note that $array[$x] is not the same thing as $array->[$x] here:

This is one of the cases we mentioned earlier in which references could spring into existence when in an lvalue context. Before this statement, $array[$x] may have been undefined. If so, it's automatically defined with a hash reference so that we can look up {"foo"} in it. Likewise $array[$x]->{"foo"} will automatically get defined with an array reference so that we can look up [0] in it. This process is called autovivification .

One more thing here. The arrow is optional between brackets subscripts, so you can shrink the above down to

Which, in the degenerate case of using only ordinary arrays, gives you multidimensional arrays just like C's:

Well, okay, not entirely like C's arrays, actually. C doesn't know how to grow its arrays on demand. Perl does.

If a reference happens to be a reference to an object, then there are probably methods to access the things referred to, and you should probably stick to those methods unless you're in the class package that defines the object's methods. In other words, be nice, and don't violate the object's encapsulation without a very good reason. Perl does not enforce encapsulation. We are not totalitarians here. We do expect some basic civility though.

# Miscellaneous Usage

Using a string or number as a reference produces a symbolic reference, as explained above. Using a reference as a number produces an integer representing its storage location in memory. The only useful thing to be done with this is to compare two references numerically to see whether they refer to the same location.

Using a reference as a string produces both its referent's type, including any package blessing as described in perlobj , as well as the numeric address expressed in hex. The ref() operator returns just the type of thing the reference is pointing to, without the address. See "ref" in perlfunc for details and examples of its use.

The bless() operator may be used to associate the object a reference points to with a package functioning as an object class. See perlobj .

A typeglob may be dereferenced the same way a reference can, because the dereference syntax always indicates the type of reference desired. So ${*foo} and ${\$foo} both indicate the same scalar variable.

Here's a trick for interpolating a subroutine call into a string:

The way it works is that when the @{...} is seen in the double-quoted string, it's evaluated as a block. The block creates a reference to an anonymous array containing the results of the call to mysub(1,2,3) . So the whole block returns a reference to an array, which is then dereferenced by @{...} and stuck into the double-quoted string. This chicanery is also useful for arbitrary expressions:

Similarly, an expression that returns a reference to a scalar can be dereferenced via ${...} . Thus, the above expression may be written as:

# Circular References

It is possible to create a "circular reference" in Perl, which can lead to memory leaks. A circular reference occurs when two references contain a reference to each other, like this:

You can also create a circular reference with a single variable:

In this case, the reference count for the variables will never reach 0, and the references will never be garbage-collected. This can lead to memory leaks.

Because objects in Perl are implemented as references, it's possible to have circular references with objects as well. Imagine a TreeNode class where each node references its parent and child nodes. Any node with a parent will be part of a circular reference.

You can break circular references by creating a "weak reference". A weak reference does not increment the reference count for a variable, which means that the object can go out of scope and be destroyed. You can weaken a reference with the weaken function exported by the Scalar::Util module, or available as builtin::weaken directly in Perl version 5.35.7 or later.

Here's how we can make the first example safer:

The reference from $foo to $bar has been weakened. When the $bar variable goes out of scope, it will be garbage-collected. The next time you look at the value of the $foo->{bar} key, it will be undef .

This action at a distance can be confusing, so you should be careful with your use of weaken. You should weaken the reference in the variable that will go out of scope first . That way, the longer-lived variable will contain the expected reference until it goes out of scope.

# Symbolic references

We said that references spring into existence as necessary if they are undefined, but we didn't say what happens if a value used as a reference is already defined, but isn't a hard reference. If you use it as a reference, it'll be treated as a symbolic reference. That is, the value of the scalar is taken to be the name of a variable, rather than a direct link to a (possibly) anonymous value.

People frequently expect it to work like this. So it does.

This is powerful, and slightly dangerous, in that it's possible to intend (with the utmost sincerity) to use a hard reference, and accidentally use a symbolic reference instead. To protect against that, you can say

and then only hard references will be allowed for the rest of the enclosing block. An inner block may countermand that with

Only package variables (globals, even if localized) are visible to symbolic references. Lexical variables (declared with my()) aren't in a symbol table, and thus are invisible to this mechanism. For example:

This will still print 10, not 20. Remember that local() affects package variables, which are all "global" to the package.

# Not-so-symbolic references

Brackets around a symbolic reference can simply serve to isolate an identifier or variable name from the rest of an expression, just as they always have within a string. For example,

has always meant to print "pop on over", even though push is a reserved word. This is generalized to work the same without the enclosing double quotes, so that

will have the same effect. This construct is not considered to be a symbolic reference when you're using strict refs:

Similarly, because of all the subscripting that is done using single words, the same rule applies to any bareword that is used for subscripting a hash. So now, instead of writing

you can write just

and not worry about whether the subscripts are reserved words. In the rare event that you do wish to do something like

you can force interpretation as a reserved word by adding anything that makes it more than a bareword:

The use warnings pragma or the -w switch will warn you if it interprets a reserved word as a string. But it will no longer warn you about using lowercase words, because the string is effectively quoted.

# Pseudo-hashes: Using an array as a hash

Pseudo-hashes have been removed from Perl. The 'fields' pragma remains available.

# Function Templates

As explained above, an anonymous function with access to the lexical variables visible when that function was compiled, creates a closure. It retains access to those variables even though it doesn't get run until later, such as in a signal handler or a Tk callback.

Using a closure as a function template allows us to generate many functions that act similarly. Suppose you wanted functions named after the colors that generated HTML font changes for the various colors:

The red() and green() functions would be similar. To create these, we'll assign a closure to a typeglob of the name of the function we're trying to build.

Now all those different functions appear to exist independently. You can call red(), RED(), blue(), BLUE(), green(), etc. This technique saves on both compile time and memory use, and is less error-prone as well, since syntax checks happen at compile time. It's critical that any variables in the anonymous subroutine be lexicals in order to create a proper closure. That's the reasons for the my on the loop iteration variable.

This is one of the only places where giving a prototype to a closure makes much sense. If you wanted to impose scalar context on the arguments of these functions (probably not a wise idea for this particular example), you could have written it this way instead:

However, since prototype checking happens at compile time, the assignment above happens too late to be of much use. You could address this by putting the whole loop of assignments within a BEGIN block, forcing it to occur during compilation.

Access to lexicals that change over time--like those in the for loop above, basically aliases to elements from the surrounding lexical scopes-- only works with anonymous subs, not with named subroutines. Generally said, named subroutines do not nest properly and should only be declared in the main package scope.

This is because named subroutines are created at compile time so their lexical variables get assigned to the parent lexicals from the first execution of the parent block. If a parent scope is entered a second time, its lexicals are created again, while the nested subs still reference the old ones.

Anonymous subroutines get to capture each time you execute the sub operator, as they are created on the fly. If you are accustomed to using nested subroutines in other programming languages with their own private variables, you'll have to work at it a bit in Perl. The intuitive coding of this type of thing incurs mysterious warnings about "will not stay shared" due to the reasons explained above. For example, this won't work:

A work-around is the following:

Now inner() can only be called from within outer(), because of the temporary assignments of the anonymous subroutine. But when it does, it has normal access to the lexical variable $x from the scope of outer() at the time outer is invoked.

This has the interesting effect of creating a function local to another function, something not normally supported in Perl.

# Postfix Dereference Syntax

Beginning in v5.20.0, a postfix syntax for using references is available. It behaves as described in "Using References" , but instead of a prefixed sigil, a postfixed sigil-and-star is used.

For example:

In Perl 5.20 and 5.22, this syntax must be enabled with use feature 'postderef' . As of Perl 5.24, no feature declarations are required to make it available.

Postfix dereference should work in all circumstances where block (circumfix) dereference worked, and should be entirely equivalent. This syntax allows dereferencing to be written and read entirely left-to-right. The following equivalencies are defined:

Note especially that $cref->&* is not equivalent to $cref->() , and can serve different purposes.

Glob elements can be extracted through the postfix dereferencing feature:

Postfix array and scalar dereferencing can be used in interpolating strings (double quotes or the qq operator), but only if the postderef_qq feature is enabled. Interpolation of postfix array highest index access ( ->$#* ) is also supported when the postderef_qq feature is enabled.

# Postfix Reference Slicing

Value slices of arrays and hashes may also be taken with postfix dereferencing notation, with the following equivalencies:

Postfix key/value pair slicing, added in 5.20.0 and documented in the Key/Value Hash Slices section of perldata , also behaves as expected:

As with postfix array, postfix value slice dereferencing can be used in interpolating strings (double quotes or the qq operator), but only if the postderef_qq feature is enabled.

# Assigning to References

Beginning in v5.22.0, the referencing operator can be assigned to. It performs an aliasing operation, so that the variable name referenced on the left-hand side becomes an alias for the thing referenced on the right-hand side:

This syntax must be enabled with use feature 'refaliasing' . It is experimental, and will warn by default unless no warnings 'experimental::refaliasing' is in effect.

These forms may be assigned to, and cause the right-hand side to be evaluated in scalar context:

Slicing operations and parentheses cause the right-hand side to be evaluated in list context:

Each element on the right-hand side must be a reference to a datum of the right type. Parentheses immediately surrounding an array (and possibly also my / state / our / local ) will make each element of the array an alias to the corresponding scalar referenced on the right-hand side:

Combining that form with local and putting parentheses immediately around a hash are forbidden (because it is not clear what they should do):

Assignment to references and non-references may be combined in lists and conditional ternary expressions, as long as the values on the right-hand side are the right type for each element on the left, though this may make for obfuscated code:

The foreach loop can also take a reference constructor for its loop variable, though the syntax is limited to one of the following, with an optional my , state , or our after the backslash:

No parentheses are permitted. This feature is particularly useful for arrays-of-arrays, or arrays-of-hashes:

CAVEAT: Aliasing does not work correctly with closures. If you try to alias lexical variables from an inner subroutine or eval , the aliasing will only be visible within that inner sub, and will not affect the outer subroutine where the variables are declared. This bizarre behavior is subject to change.

# Declaring a Reference to a Variable

Beginning in v5.26.0, the referencing operator can come after my , state , our , or local . This syntax must be enabled with use feature 'declared_refs' . It is experimental, and will warn by default unless no warnings 'experimental::refaliasing' is in effect.

This feature makes these:

equivalent to:

It is intended mainly for use in assignments to references (see "Assigning to References" , above). It also allows the backslash to be used on just some items in a list of declared variables:

# WARNING: Don't use references as hash keys

You may not (usefully) use a reference as the key to a hash. It will be converted into a string:

If you try to dereference the key, it won't do a hard dereference, and you won't accomplish what you're attempting. You might want to do something more like

And then at least you can use the values(), which will be real refs, instead of the keys(), which won't.

The standard Tie::RefHash module provides a convenient workaround to this.

Besides the obvious documents, source code can be instructive. Some pathological examples of the use of references can be found in the t/op/ref.t regression test in the Perl source directory.

See also perldsc and perllol for how to use references to create complex data structures, and perlootut and perlobj for how to use them to create objects.

Perldoc Browser is maintained by Dan Book ( DBOOK ). Please contact him via the GitHub issue tracker or email regarding any issues with the site itself, search, or rendering of documentation.

The Perl documentation is maintained by the Perl 5 Porters in the development of Perl. Please contact them via the Perl issue tracker , the mailing list , or IRC to report any issues with the contents or format of the documentation.

Perl Onion

  •   AUTHORS
  •   CATEGORIES
  • #   TAGS

Perl foreach loops

Sep 23, 2018 by brian d foy

perl assign list

A foreach loop runs a block of code for each element of a list. No big whoop, “perl foreach” continues to be one of the most popular on Google searches for the language. So we thought we’d see what’s happened in 20 years. I expand on Tom Christiansen’s slide that’s part of his longer presentation then add a new but experimental feature at the end. If you want more, there’s plenty to read in perlsyn or my book Learning Perl .

Going through a list

Unless you say otherwise, foreach aliases the current element to the topic variable $_ . You can specify that list directly in the parentheses after foreach , use an array variable, or use the result of a subroutine call (amongst other ways to get a list):

Some people like to use the synonym for . There’s a proper C-style for that has three semicolon-separated parts in the parentheses. If Perl doesn’t see the two semicolons it treats for just like a foreach :

Element source gotchas

The aliasing is only temporary. After the foreach the topic variable returns to its original value:

The output shows that $_ appears unaffected by the foreach :

This is an alias instead of a copy, which is a shortcut that allows your program to be a little faster by not moving data around. If you change the topic you change the original value if the list source is an array (the values are read-only otherwise and you’ll get an error):

Not only that, but if you change the source by adding or removing elements you can screw up the foreach . This loops infinitely processing the same element because each go through the block moves the array elements over one position; when the iterator moves onto the next position it finds the same one it just saw:

This output will go on forever:

Naming your own topic variable

The $_ is often handy because it’s the default variable for several Perl functions, such as chomp or split . You can use your own name by specifying a scalar variable between the foreach and the parentheses. Usually you don’t want to use that variable for something other than the loop so the usual style declares it inline with the foreach :

Since Perl flattens lists into one big list, you can use more than one list source in the parentheses:

Or a mix of source types:

Using your own named topic variable acts just like what you saw with $_ :

The output shows the aliasing effect and that the original value is restored after the foreach :

Controlling

There are three keywords that let you control the operation of the foreach (and other looping structures): last , next , and redo .

The last stops the current iteration. It’s as if you immediately go past the last statement in the block then breaks out of the loop. It does not look at the next item. You often use this with a postfix conditional:

You start the block for element 3 but end the loop there and continue the program after the loop:

The next stops the current iteration and moves on to the next one. This makes it easy to skip elements that you don’t want to process:

The output shows that you run the block with each element but only the even numbers make it past the next :

The redo restarts the current iteration of a block. You can use it with a foreach although it’s more commonly used with looping structures that aren’t meant to go through a list of items.

Here’s an example where you want to get three “good” lines of input. You iterate through the number of lines that you want and read standard input each time. If you get a blank line, you restart the same loop with

The output shows that the loop effectively ignore the blank lines and goes back to the top of the loop. It does not use the next item in the list though. After getting a blank line when it tries to read the second line, it tries the second line again:

That’s not very Perly though but this is an article about foreach . A better style might be to read lines with while to the point that @lines is large enough:

There’s more that you can do with these. The work with labels and nested loops. You can read more about them in perlsyn or Learning Perl .

A common file-reading gotcha

Since foreach goes through each element of a list, some people reach for it when they want to go through each line in a file:

This is usually not a good idea. The foreach needs to have to entire list all at once. This isn’t a lazy construct like you’d see in some other languages. This means that the foreach reads in all of standard input before it does anything. And, if standard input doesn’t close, the program appears to hang. Or worse, it tries to completely read terabytes of data from that filehandle. Memory is cheap, but not that cheap.

A suitable replacement is the while idiom that reads and processes one line at a time:

This is really a shortcut for an assignment in scalar context. That reads only one line from the filehandle:

An experimental convenience

Perl v5.22 added an experimental refaliasing feature . Assigning to a reference makes the thing on the right an alias for the thing on the left. Here’s a small demonstration where you assign an anonymous hash to a reference to a named hash variable. Now %h is another name (the alias) for that hash reference:

This is handy in a foreach where the elements of the list are hash references. First, here’s how you might do this without the feature. Inside the block you interact the $hash as a reference; you must dereference it to get to a value:

With v5.22’s refaliasing feature you can use a named hash variable as the topic. Inside the block you interact with the current element as a named hash. There’s no -> for a dereference:

The output is the same in both programs:

There’s a warning from this experimental feature (and, all such features). The feature might change or even disappear according to Perl’s feature policy . Disable the warning if you are comfortable with that:

The foreach is a handy way to go through a list an element at a time. Use it when you already have the list completely constructed (and not to process a filehandle). Define your own topic variable to choose a descriptive name.

brian d foy

brian d foy is a Perl trainer and writer, and a senior editor at Perl.com. He’s the author of Mastering Perl , Mojolicious Web Clients , Learning Perl Exercises , and co-author of Programming Perl , Learning Perl , Intermediate Perl and Effective Perl Programming .

Browse their articles

Something wrong with this article? Help us out by opening an issue or pull request on GitHub

To get in touch, send an email to [email protected] , or submit an issue to tpf/perldotcom on GitHub.

This work is licensed under a Creative Commons Attribution-NonCommercial 3.0 Unported License .

Creative Commons License

Perl.com and the authors make no representations with respect to the accuracy or completeness of the contents of all work on this website and specifically disclaim all warranties, including without limitation warranties of fitness for a particular purpose. The information published on this website may not be suitable for every situation. All work on this website is provided with the understanding that Perl.com and the authors are not engaged in rendering professional services. Neither Perl.com nor the authors shall be liable for damages arising herefrom.

Perl Tutorial

  • Perl Basics
  • Perl - Home
  • Perl - Introduction
  • Perl - Environment
  • Perl - Syntax Overview
  • Perl - Data Types
  • Perl - Variables
  • Perl - Scalars

Perl - Arrays

  • Perl - Hashes
  • Perl - IF...ELSE
  • Perl - Loops
  • Perl - Operators
  • Perl - Date & Time
  • Perl - Subroutines
  • Perl - References
  • Perl - Formats
  • Perl - File I/O
  • Perl - Directories
  • Perl - Error Handling
  • Perl - Special Variables
  • Perl - Coding Standard
  • Perl - Regular Expressions
  • Perl - Sending Email
  • Perl Advanced
  • Perl - Socket Programming
  • Perl - Object Oriented
  • Perl - Database Access
  • Perl - CGI Programming
  • Perl - Packages & Modules
  • Perl - Process Management
  • Perl - Embedded Documentation
  • Perl - Functions References
  • Perl Useful Resources
  • Perl - Questions and Answers
  • Perl - Quick Guide
  • Perl - Useful Resources
  • Perl - Discussion
  • Selected Reading
  • UPSC IAS Exams Notes
  • Developer's Best Practices
  • Questions and Answers
  • Effective Resume Writing
  • HR Interview Questions
  • Computer Glossary

An array is a variable that stores an ordered list of scalar values. Array variables are preceded by an "at" (@) sign. To refer to a single element of an array, you will use the dollar sign ($) with the variable name followed by the index of the element in square brackets.

Here is a simple example of using the array variables −

Here we have used the escape sign (\) before the $ sign just to print it. Other Perl will understand it as a variable and will print its value. When executed, this will produce the following result −

In Perl, List and Array terms are often used as if they're interchangeable. But the list is the data, and the array is the variable.

Array Creation

Array variables are prefixed with the @ sign and are populated using either parentheses or the qw operator. For example −

The second line uses the qw// operator, which returns a list of strings, separating the delimited string by white space. In this example, this leads to a four-element array; the first element is 'this' and last (fourth) is 'array'. This means that you can use different lines as follows −

You can also populate an array by assigning each value individually as follows −

Accessing Array Elements

When accessing individual elements from an array, you must prefix the variable with a dollar sign ($) and then append the element index within the square brackets after the name of the variable. For example −

This will produce the following result −

Array indices start from zero, so to access the first element you need to give 0 as indices. You can also give a negative index, in which case you select the element from the end, rather than the beginning, of the array. This means the following −

Sequential Number Arrays

Perl offers a shortcut for sequential numbers and letters. Rather than typing out each element when counting to 100 for example, we can do something like as follows −

Here double dot (..) is called range operator . This will produce the following result −

The size of an array can be determined using the scalar context on the array - the returned value will be the number of elements in the array −

The value returned will always be the physical size of the array, not the number of valid elements. You can demonstrate this, and the difference between scalar @array and $#array, using this fragment is as follows −

There are only four elements in the array that contains information, but the array is 51 elements long, with a highest index of 50.

Adding and Removing Elements in Array

Perl provides a number of useful functions to add and remove elements in an array. You may have a question what is a function? So far you have used print function to print various values. Similarly there are various other functions or sometime called sub-routines, which can be used for various other functionalities.

Slicing Array Elements

You can also extract a "slice" from an array - that is, you can select more than one item from an array in order to produce another array.

The specification for a slice must have a list of valid indices, either positive or negative, each separated by a comma. For speed, you can also use the .. range operator −

Replacing Array Elements

Now we are going to introduce one more function called splice() , which has the following syntax −

This function will remove the elements of @ARRAY designated by OFFSET and LENGTH, and replaces them with LIST, if specified. Finally, it returns the elements removed from the array. Following is the example −

Here, the actual replacement begins with the 6th number after that five elements are then replaced from 6 to 10 with the numbers 21, 22, 23, 24 and 25.

Transform Strings to Arrays

Let's look into one more function called split() , which has the following syntax −

This function splits a string into an array of strings, and returns it. If LIMIT is specified, splits into at most that number of fields. If PATTERN is omitted, splits on whitespace. Following is the example −

Transform Arrays to Strings

We can use the join() function to rejoin the array elements and form one long scalar string. This function has the following syntax −

This function joins the separate strings of LIST into a single string with fields separated by the value of EXPR, and returns the string. Following is the example −

Sorting Arrays

The sort() function sorts each element of an array according to the ASCII Numeric standards. This function has the following syntax −

This function sorts the LIST and returns the sorted array value. If SUBROUTINE is specified then specified logic inside the SUBTROUTINE is applied while sorting the elements.

Please note that sorting is performed based on ASCII Numeric value of the words. So the best option is to first transform every element of the array into lowercase letters and then perform the sort function.

The $[ Special Variable

So far you have seen simple variable we defined in our programs and used them to store and print scalar and array values. Perl provides numerous special variables, which have their predefined meaning.

We have a special variable, which is written as $[ . This special variable is a scalar containing the first index of all arrays. Because Perl arrays have zero-based indexing, $[ will almost always be 0. But if you set $[ to 1 then all your arrays will use on-based indexing. It is recommended not to use any other indexing other than zero. However, let's take one example to show the usage of $[ variable −

Merging Arrays

Because an array is just a comma-separated sequence of values, you can combine them together as shown below −

The embedded arrays just become a part of the main array as shown below −

Selecting Elements from Lists

The list notation is identical to that for arrays. You can extract an element from an array by appending square brackets to the list and giving one or more indices −

Similarly, we can extract slices, although without the requirement for a leading @ character −

Perl Language

  • Getting started with Perl Language
  • Awesome Book
  • Awesome Community
  • Awesome Course
  • Awesome Tutorial
  • Awesome YouTube
  • Attributed Text
  • Best Practices
  • Compile Perl cpan module sapnwrfc from source code
  • Control Statements
  • Dates and Time
  • Debug Output
  • Easy way to check installed modules on Mac and Ubuntu
  • Exception handling
  • File I/O (reading and writing files)
  • GUI Applications in Perl
  • Install Perl modules via CPAN
  • Installation of Perl
  • Interpolation in Perl
  • Array as list
  • Assigning a list to a hash
  • Hash as list
  • Lists can be passed into subroutines
  • Return list from subroutine
  • Using arrayref to pass array to sub
  • Memory usage optimization
  • Object-oriented Perl
  • Pack and unpack
  • Packages and modules
  • Perl commands for Windows Excel with Win32::OLE module
  • Perl one-liners
  • Perl script debugging
  • Perl Testing
  • Reading a file's content into a variable
  • Regular Expressions
  • Simple interaction with database via DBI module
  • Special variables
  • Split a string on unquoted separators
  • Strings and quoting methods
  • Subroutines
  • True and false
  • XML Parsing

Perl Language Lists Assigning a list to a hash

Lists can also be assigned to hash variables. When creating a list that will be assigned to a hash variable, it is recommended to use the fat comma => between keys and values to show their relationship:

The => is really only a special comma that automatically quotes the operand to its left. So, you could use normal commas, but the relationship is not as clear:

You can also use quoted strings for the left hand operand of the fat comma => , which is especially useful for keys containing spaces.

For details see Comma operator at perldoc perlop .

Got any Perl Language Question?

pdf

  • Advertise with us
  • Privacy Policy

Get monthly updates about new articles, cheatsheets, and tricks.

Advanced Perl Maven

  • Introduction to the Advanced Perl course
  • Perl 4 libraries
  • The problem with Perl 4 style libraries
  • Namespaces and packages in Perl
  • Modules in Perl
  • How does require find the module to be loaded?
  • What is the difference between require and use in Perl? What does import do?
  • Exporting and importing functions easily
  • Restrict the import by listing the functions to be imported
  • Import on demand
  • Modules - Behind the scenes
  • Tools to package Perl scripts, modules, and applications
  • Distribution directory layout
  • Makefile.PL of ExtUtils::MakeMaker
  • Makefile.PL of Module::Install
  • Build.PL of Module::Build
  • Changes and README files in a Perl distribution
  • MANIFEST and MANIFEST.SKIP
  • Packaging a Perl script and a Perl module
  • Packaging with Makefile.PL
  • Packaging with Build.PL
  • A test file in Perl
  • How to create a Perl Module for code reuse?
  • Passing two arrays to a function

Array references in Perl

  • Static and state variables in Perl
  • Filtering values using Perl grep
  • Transforming a Perl array using map
  • Core Perl OOP: Constructor
  • Core Perl OOP: attributes, getter - setter
  • What should setters return? (Examples with core Perl OOP)
  • Core Perl OOP: Constructor arguments
  • Accessor with type constraint
  • Class as type constraint
  • Always use strict and use warnings in your perl code!
  • How to capture and save warnings in Perl
  • use diagnostic; or use splain
  • Splice to slice and dice arrays in Perl
  • AUTOLOAD - handling Undefined subroutines
  • BEGIN block - running code during compilation
  • END block - running code after the application has ended
  • How to sort faster in Perl? (using the Schwartzian transform)
  • $_ the default variable of Perl
  • ARRAY(0x703dcf2)
  • Data::Dumper

Creating a reference to a Perl array

Dereferencing an array, individual elements, array references cheat sheet, data::dumper for debugging.

Gabor Szabo

Published on 2015-12-09

Author: Gabor Szabo

perl assign list

  • Trending Now
  • Data Structures & Algorithms
  • Foundational Courses
  • Data Science
  • Practice Problem
  • Machine Learning
  • System Design
  • DevOps Tutorial
  • Web Development
  • Web Browser

Related Articles

  • Solve Coding Problems
  • Perl | Multidimensional Hashes
  • Perl - Creating a Hash from an Array
  • Coercions in Perl
  • Perl | Hash Operations
  • Perl | Reading Excel Files
  • Perl | Breakpoints of a Debugger
  • Barewords in Perl
  • Perl - Taint() Method
  • Perl | DBI(Database Independent Interface) Module Set - 1
  • HTML Form Tampering in Perl
  • Perl | Recursive Subroutines
  • Sorting Hash in Perl
  • Downloading Files from Web using Perl
  • Packages in Perl
  • Perl | Directories with CRUD operations
  • Perl | Static and Dynamic content in CGI
  • Sending an email using Perl
  • Perl - Introduction to Debugger

Perl | Hash in Scalar and List Context

Hash in LIST Context

Syntax : my @list = %hash;
  • In the List context in Perl, the operator can be used to obtain multiple values between the supplied range. Example: @hundred = (0..100); Above example if put into a print statement will result in printing a range of numbers from 0 to 100.
  • The sorting of a hash by its keys or values can be easily accomplished by using List Context. After converting the hash into a list of its keys or values, sort that list and then store the corresponding keys or values in the sorted order.
@keys = keys %hash; if (@keys) { ….Code…. }

Hash in SCALAR context

Syntax : my $list = %hash;
my $list = %hash; if ($list) { ….Code…. }
  • It helps in finding out whether Perl’s internal hashing algorithm is performing poorly on our data set. For example , We place 10 things in a hash, but evaluating %HASH in scalar context reveals “1/16”, which means only one out of sixteen buckets has been touched and presumably contains all 10 of your items. This isn’t supposed to happen.
@keys = keys %hash; $size = @keys;

Please Login to comment...

  • Perl-hashes

Improve your Coding Skills with Practice

 alt=

What kind of Experience do you want to share?

IMAGES

  1. Beginner Perl Maven tutorial 4.3

    perl assign list

  2. Perl Variables

    perl assign list

  3. Beginner Perl Maven tutorial 4.5

    perl assign list

  4. Perl tutorial: Lists and Arrays (Lesson 2)

    perl assign list

  5. Add HTML to List Using Perl

    perl assign list

  6. Add HTML to List Using Perl

    perl assign list

VIDEO

  1. Perl Tutorial

  2. Shop at perlcosmetics.com ✨

  3. #01 Perlの基礎

  4. PERL COIN FAKE PUMP UPDATE IN NOVEMBER 2023❗ PERL.ECO MASSIVE TRAP❗ BINANCE TO DELIST PERLIN❗ BEWARE

  5. PERL COIN COLLAPSE IN NOVEMBER 2023‼️ BINANCE DELIST PERLIN SOON‼️ PERL.ECO PRICE DUMP HARD

  6. Denon PerL

COMMENTS

  1. Perl List

    A Perl list is a sequence of scalar values. You use parenthesis and comma operators to construct a list. Each value is the list is called list element. List elements are indexed and ordered. You can refer to each element by its position. Simple Perl list The following example defines some simple lists:

  2. Perl Array

    In order to change a list, you need to store it in an array variable. By definition, an array is a variable that provides dynamic storage for a list. In Perl, the terms array and list are used interchangeably, but you have to note an important difference: a list is immutable whereas an array is mutable.

  3. perl

    1 @darch, That make no sense. ($hello, $there, $world) (and (7,8)) cannot be executed in scalar context in ($hello, $there, $world) = (7,8). The list assignment could return 3 if it wanted to, but there's no reason to. - ikegami Feb 17, 2012 at 5:11

  4. perllol

    The simplest two-level data structure to build in Perl is an array of arrays, sometimes casually called a list of lists. It's reasonably easy to understand, and almost everything that applies here will also be applicable later on with the fancier data structures.

  5. perlop

    Assignment Operators Comma Operator List Operators (Rightward) Logical Not Logical And Logical or and Exclusive Or C Operators Missing From Perl Quote and Quote-like Operators Regexp Quote-Like Operators Quote-Like Operators Gory details of parsing quoted constructs

  6. List Assignment (Learning Perl, 3rd Edition)

    3.4. List Assignment In much the same way as scalar values may be assigned to variables, list values may also be assigned to variables: ($fred, $barney, $dino) = ("flintstone", "rubble", undef); All three variables in the list on the left get new values, just as if we did three separate assignments.

  7. How to assign an array to a value in hash?

    How to assign an array to a value in hash? : perlquestion . print w/replies, xml ) Need Help?? shilpam has asked for the wisdom of the Perl Monks concerning the following question: I want to assign an array to the value of hash. The key is scalar varaible. At a later stage in program, I need to access the key-value pairs.

  8. Perl

    In Perl, people use term list and array interchangeably, however there is a difference. The list is the data (ordered collection of scalar values) and the array is a variable that holds the list. How to define array? Arrays are prefixed with @ sign. This is how you define an array - @friends = ("Ajeet", "Chaitanya", "Rahul");

  9. Scalar and List context in Perl, the size of an array

    Sometimes you might see code like this: 0 + @words; This is basically a tricky way to get the size of the array. The + operator creates SCALAR context on both sides. An array will return its size in SCALAR context. Adding 0 to it does not change the number, so the above expression returns the size of the array.

  10. perlLoL

    You see, assigning a named list like that to a scalar just counts the number of elements in @tmp, which probably isn't what you want. If you are running under use strict , you'll have to add some declarations to make it happy:

  11. perlref

    Assigning to References Declaring a Reference to a Variable WARNING: Don't use references as hash keys SEE ALSO NAME perlref - Perl references and nested data structures NOTE This is complete documentation about all aspects of references. For a shorter, tutorial introduction to just the essential features, see perlreftut. DESCRIPTION

  12. Perl foreach loops

    Going through a list Unless you say otherwise, foreach aliases the current element to the topic variable $_. You can specify that list directly in the parentheses after foreach, use an array variable, or use the result of a subroutine call (amongst other ways to get a list): foreach ( 1, 3, 7 ) { print "\$_ is $_"; }

  13. Perl

    Perl - Arrays. Next. An array is a variable that stores an ordered list of scalar values. Array variables are preceded by an "at" (@) sign. To refer to a single element of an array, you will use the dollar sign ($) with the variable name followed by the index of the element in square brackets. Here is a simple example of using the array ...

  14. Perl Language Tutorial => Assigning a list to a hash

    Lists can also be assigned to hash variables. When creating a list that will be assigned to a hash variable, it is recommended to use the fat comma => between keys and values to show their relationship: my %hash = ( foo => 42, bar => 43, baz => 44 ); The => is really only a special comma that automatically quotes the operand to its left.

  15. Array references in Perl

    $#$ @ { } ARRAY (0x703dcf2) Data::Dumper Prev Next In this part of the Perl Tutorial we are going to learn about array references . There are two main uses of array references. One is to make it easy to pass more than one arrays to a subroutine , the other is to build arrays of arrays or other multi-dimensional data structures.

  16. Perl

    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. Example: Array Creation: In Perl programming every array variable is declared using "@" sign before ...

  17. Perl

    Prerequisite: Perl Hash Hash in Perl is a set of key/value pairs. Perl provides us the flexibility to assign the hash to a List type and a Scalar type, known as LIST Context and SCALAR Context respectively.. Hash in LIST Context. The assignment of a hash to a list type in Perl is accomplished by making a list with the keys and values as its elements.

  18. perl

    Teams. Q&A for work. Connect and share knowledge within a single location that is structured and easy to search. Learn more about Teams

  19. What is the best way to ignore elements in a perl list assignment

    What is the best way to ignore elements in a perl list assignment? Ask Question Asked today Modified today Viewed 8 times 0 I am using a list assignment to assign tab separated values to different variables, like so: perl -E ' (my $first, my $second, my $third) = split (/\t/, qq [a\tb\tc]); say $first; say $second; say $third;' a b c