perl assign hash to another hash

Home » Perl Hash

Summary : in this tutorial, you’ll learn about another compound data type called Perl hash and how to manipulate hash elements effectively.

Introduction to Perl hash

A Perl hash is defined by key-value pairs. Perl stores elements of a hash in such an optimal way that you can look up its values based on keys very fast.

With the array , you use indices to access its elements. However, you must use descriptive keys to access hash element. A hash is sometimes referred to as an associative array.

Like a scalar or an array variable , a hash variable has its own prefix. A hash variable must begin with a percent sign ( % ). The prefix % looks like key/value pair so remember this trick to name the hash variables.

The following example defines a simple hash.

To make the code easier to read, Perl provides the => operator as an alternative to a comma (,). It helps differentiate between keys and values and makes the code more elegant.

When you see the => operator, you know that you are dealing with a hash, not a list or an array .

The $countries hash can be rewritten using => operator as follows:

Perl requires the keys of a hash to be strings, meanwhile, the values can be any scalars. If you use non-string values as the keys, you may get an unexpected result.

In addition, a hash key must be unique. If you try to add a new key-value pair with the key that already exists, the value of the existing key will be over-written.

Notice that you can omit the quotation in the keys of the hash.

Perl hash operations

In the following section, we will examine the most commonly used operation in the hash.

Look up Perl hash values

You use a hash key inside curly brackets {} to look up a hash value. Take a look at the following example:

Add a new element

To add a new element to hash, you use a new key-pair value as follows:

Remove a single key/value pair

If you know the hash key, you can remove single key-value pair from the hash by using delete() function as follows:

Modify hash elements

You can modify the value of the existing key/value pair by assigning a new value as shown in the following example:

Loop over Perl hash elements

Perl provides the keys() function that allows you to get a list of keys in scalars. You can use the keys() function in a for loop statement to iterate the hash elements:

The keys() function returns a list of hash keys. The for loop visits each key and assigns it to a special variable $_ . Inside the loop, we access the value of a hash element via its key as $langs{$_} .

In this tutorial, you’ve learned about Perl hash and some techniques to manipulate hash elements.

Perl hash add element - How to add an element to a Perl hash

Perl hash "add" FAQ: How do I add a new element to a Perl hash? (Or, How do I push a new element onto a Perl hash?)

The Perl hash is a cool programming construct, and was very unique when I was learning programming languages in the late 1980s. A Perl hash is basically an array, but the keys of the array are strings instead of numbers.

Basic Perl hash "add element" syntax

To add a new element to a Perl hash , you use the following general syntax:

As a concrete example, here is how I add one element (one key/value pair) to a Perl hash named %prices :

In that example, my hash is named %prices , the key I'm adding is the string pizza , and the value I'm adding is 12.00 .

To add more elements to the Perl hash, just use that same syntax over and over, like this:

(Note that there is no "Perl push" syntax for adding a new element to a Perl hash, but because people ask me that so many times, I wanted to make sure I mentioned it here.)

A complete Perl hash add element example

To help demonstrate this better, here's the source code for a complete script that shows how to add elements to a Perl hash, and then shows a simple way to traverse the hash and print each hash element (each key/value pair):

I hope this Perl hash add element tutorial is a helpful reference for you.

Related Perl hash tutorials

I hope you found this short Perl hash tutorial helpful. We have many more Perl hash tutorials on this site, including the following:

Getting started Perl hash tutorials:

• Perl hash introduction/tutorial
• Perl foreach and while: how to loop over the elements in a Perl hash
• Perl hash add - How to add an element to a Perl hash
• How to print each element in a Perl hash

More advanced Perl hash tutorials:

• How to see if a Perl hash contains a key
• How to delete an element from a Perl hash by key

The hash in Perl - hash sorting tutorials:

• Perl hash sorting - Sort a Perl hash by the hash key
• Perl hash sorting - Sort a Perl hash by the hash value

Help keep this website running!

• Perl hash introduction tutorial
• Perl hash sort - How to sort a Perl hash by the hash value
• How to add an item to a Perl hash
• My Perl hash tutorials
• Perl array push and pop syntax and examples

books by alvin

• Maine Cabin Masters Black Pirate Flag (skull and crossbones)
• Moon’s First Murder (a lucid dream story)
• Lucid dream: Waking up in a hospital
• ZIO, ZIO HTTP Server, and Scala-Cli
• This was going to be my office in Palmer, Alaska

• PyQt5 ebook
• Tkinter ebook
• SQLite Python
• wxPython ebook
• Windows API ebook
• Java Swing ebook
• Java games ebook
• MySQL Java ebook

last modified August 24, 2023

Perl hash tutorial shows how to work with hashes in Perl.

A hash is an associative array of scalars. It is a collection of key/value pairs. Each value is uniquely identified by its key.

A hash is a basic Perl data type. A data type is a set of values and operations that can be done with these values.

In other programming languages such as C# or Python, a hash is often called a dictionary.

Perl uses the % sigil to define a hash.

The => characters can be used to separate keys and values in a literal hash declaration.

Perl simple hash

In the following example, we work with a simple hash.

In the example, we define a hash of words. We print individual values, key/value pairs and keys and values of the hash.

A Perl hash of words is defined. The hash uses the % character.

We print the value that is stored with key 0. When we refer to and individual value of a hash, we use the $ character and a pair of curly {} brackets.

With the map function, we print all the key/value pairs of the hash.

With the keys function, we get the keys of the hash.

With the values function, we get the values of the hash.

Perl hash size

In the following example, we determine the size of the hash.

To get the size of an hash, we use the keys function in the scalar context.

Perl has add remove elements

In the next example we show how to add and remove elements in a hash.

First, we initialize an empty hash. We add three pairs to the hash, remove one pair, and finally clear the hash. We show the contents of the hash with Data::Dumper .

An empty hash is initialized.

We add three key/value pairs to the hash.

A pair is removed with delete function.

We clear the hash.

Perl hash iterate

We can iterate over hash items with for and foreach keywords.

In the example, we iterate over the hash of words.

Perl hash sort

With the sort function, we can sort hash items by their keys or values. By default, the hash items are unordered.

In the example, we use the sort and reverse functions to sort keys and values of the hash in ascending and descending orders.

Perl compare hashes

With the Data::Compare module, we can compare Perl data structures.

The example compares two hashes with Data::Compare .

The Compare function takes two hash references as parameters.

Perl hash slice

It is possible to extract a list of values from a hash.

In the example, we take two words from a list of words.

We use the @ sigil to get the slice.

In this article we have worked with hash data type in Perl.

My name is Jan Bodnar and I am a passionate programmer with many years of programming experience. I have been writing programming articles since 2007. So far, I have written over 1400 articles and 8 e-books. I have over eight years of experience in teaching programming.

List all Perl tutorials .

List all ASP.NET tutorials .

A Perl hash variable stores a set of key/values pairs. The hash variable name begins with the % symbol. To refer to a single pair of a hash, the variable name must start with a $ followed by the "key" of the pair in curly brackets ( {} ).

Example assigning values to hash pairs:

Values to hash pairs can be created by using a list as shown above, where the first element of the pair is used as the key and the second element is used as the value and so forth. For clarity, the string => can be used as an alias to specify the pairs. For example:

Another method for assigning a value to a named key, one by one, is via a direct assignment:

Extracting Keys and Values from a Hash variable

The list of all the keys from a hash is provided by the keys function, in the syntax: keys %hashname . The list of all the values from a hash is provided by the values function, in the syntax: values %hashname . Both the keys and values function return an array.

For example:

In order to get the hash size, or how many key-value pairs it has, one can get the size of the keys %hashname array, similar to getting the size of an array variable.

Adding and Removing key-value pairs from a hash variable

Adding a new key-value pair can be done by direct assignement. Removing an existing key-value pair can be done using the delete function operating on the hashname and specified key. For example:

Slicing a hash is selecting more than one value from pair elements in a hash to create an array. Slicing the hash is similar to slicing arrays. The specification of a slice must be a list of comma-delimited valid hash key values. Note the @ prefix is used for the hash variable to store the returned array variable.

To test for the existence of a key, you can use the exists function.

An array holds a list of family member names. The first hash contains favorite shoe color per person name. The second hash contains shoe size per person name. Evaluate and print the favorite show color size per each family member. Output lines should be in the format: "Homer wears brown shoes size 12".

Copyright © 2001 O'Reilly & Associates. All rights reserved.

• Restricted hashes
• Operating on references to hashes.

Hash::Util - A selection of general-utility hash subroutines

# DESCRIPTION

Hash::Util and Hash::Util::FieldHash contain special functions for manipulating hashes that don't really warrant a keyword.

Hash::Util contains a set of functions that support restricted hashes . These are described in this document. Hash::Util::FieldHash contains an (unrelated) set of functions that support the use of hashes in inside-out classes , described in Hash::Util::FieldHash .

By default Hash::Util does not export anything.

# Restricted hashes

5.8.0 introduces the ability to restrict a hash to a certain set of keys. No keys outside of this set can be added. It also introduces the ability to lock an individual key so it cannot be deleted and the ability to ensure that an individual value cannot be changed.

This is intended to largely replace the deprecated pseudo-hashes.

Restricts the given %hash's set of keys to @keys. If @keys is not given it restricts it to its current keyset. No more keys can be added. delete() and exists() will still work, but will not alter the set of allowed keys. Note : the current implementation prevents the hash from being bless()ed while it is in a locked state. Any attempt to do so will raise an exception. Of course you can still bless() the hash before you call lock_keys() so this shouldn't be a problem.

Removes the restriction on the %hash's keyset.

Note that if any of the values of the hash have been locked they will not be unlocked after this sub executes.

Both routines return a reference to the hash operated on.

Similar to lock_keys() , with the difference being that the optional key list specifies keys that may or may not be already in the hash. Essentially this is an easier way to say

Returns a reference to %hash

Locks and unlocks the value for an individual key of a hash. The value of a locked key cannot be changed.

Unless %hash has already been locked the key/value could be deleted regardless of this setting.

Returns a reference to the %hash.

lock_hash() locks an entire hash, making all keys and values read-only. No value can be changed, no keys can be added or deleted.

unlock_hash() does the opposite of lock_hash(). All keys and values are made writable. All values can be changed and keys can be added and deleted.

lock_hash() locks an entire hash and any hashes it references recursively, making all keys and values read-only. No value can be changed, no keys can be added or deleted.

This method only recurses into hashes that are referenced by another hash. Thus a Hash of Hashes (HoH) will all be restricted, but a Hash of Arrays of Hashes (HoAoH) will only have the top hash restricted.

unlock_hash_recurse() does the opposite of lock_hash_recurse(). All keys and values are made writable. All values can be changed and keys can be added and deleted. Identical recursion restrictions apply as to lock_hash_recurse().

Returns true if the hash and its keys are locked.

Returns true if the hash and its keys are unlocked.

Returns the list of the keys that are legal in a restricted hash. In the case of an unrestricted hash this is identical to calling keys(%hash).

Returns the list of the keys that are legal in a restricted hash but do not have a value associated to them. Thus if 'foo' is a "hidden" key of the %hash it will return false for both defined and exists tests.

In the case of an unrestricted hash this will return an empty list.

NOTE this is an experimental feature that is heavily dependent on the current implementation of restricted hashes. Should the implementation change, this routine may become meaningless, in which case it will return an empty list.

Populates the arrays @keys with the all the keys that would pass an exists tests, and populates @hidden with the remaining legal keys that have not been utilized.

Returns a reference to the hash.

In the case of an unrestricted hash this will be equivalent to

NOTE this is an experimental feature that is heavily dependent on the current implementation of restricted hashes. Should the implementation change this routine may become meaningless in which case it will behave identically to how it would behave on an unrestricted hash.

hash_seed() returns the seed bytes used to randomise hash ordering.

Note that the hash seed is sensitive information : by knowing it one can craft a denial-of-service attack against Perl code, even remotely, see "Algorithmic Complexity Attacks" in perlsec for more information. Do not disclose the hash seed to people who don't need to know it. See also "PERL_HASH_SEED_DEBUG" in perlrun .

Prior to Perl 5.17.6 this function returned a UV, it now returns a string, which may be of nearly any size as determined by the hash function your Perl has been built with. Possible sizes may be but are not limited to 4 bytes (for most hash algorithms) and 16 bytes (for siphash).

hash_value($string) returns the current perl's internal hash value for a given string. hash_value($string, $seed) returns the hash value as if computed with a different seed. If the custom seed is too short, the function errors out. The minimum length of the seed is implementation-dependent.

Returns a 32-bit integer representing the hash value of the string passed in. The 1-parameter value is only reliable for the lifetime of the process. It may be different depending on invocation, environment variables, perl version, architectures, and build options.

Note that the hash value of a given string is sensitive information : by knowing it one can deduce the hash seed which in turn can allow one to craft a denial-of-service attack against Perl code, even remotely, see "Algorithmic Complexity Attacks" in perlsec for more information. Do not disclose the hash value of a string to people who don't need to know it. See also "PERL_HASH_SEED_DEBUG" in perlrun .

Return a set of basic information about a hash.

Fields are as follows:

See also bucket_stats() and bucket_array().

Returns a list of statistics about a hash.

See also bucket_info() and bucket_array().

Note that Hash Quality Score would be 1 for an ideal hash, numbers close to and below 1 indicate good hashing, and number significantly above indicate a poor score. In practice it should be around 0.95 to 1.05. It is defined as:

The formula is from the Red Dragon book (reformulated to use the data available) and is documented at http://www.strchr.com/hash_functions

Returns a packed representation of the bucket array associated with a hash. Each element of the array is either an integer K, in which case it represents K empty buckets, or a reference to another array which contains the keys that are in that bucket.

Note that the information returned by bucket_array is sensitive information : by knowing it one can directly attack perl's hash function which in turn may allow one to craft a denial-of-service attack against Perl code, even remotely, see "Algorithmic Complexity Attacks" in perlsec for more information. Do not disclose the output of this function to people who don't need to know it. See also "PERL_HASH_SEED_DEBUG" in perlrun . This function is provided strictly for debugging and diagnostics purposes only, it is hard to imagine a reason why it would be used in production code.

Return a formatted report of the information returned by bucket_stats(). An example report looks like this:

The first set of stats gives some summary statistical information, including the quality score translated into "Good", "Poor" and "Bad", (score<=1.05, score<=1.2, score>1.2). See the documentation in bucket_stats() for more details.

The two sets of barcharts give stats and a visual indication of performance of the hash.

The first gives data on bucket chain lengths and provides insight on how much work a fetch *miss* will take. In this case we have to inspect every item in a bucket before we can be sure the item is not in the list. The performance for an insert is equivalent to this case, as is a delete where the item is not in the hash.

The second gives data on how many keys are at each depth in the chain, and gives an idea of how much work a fetch *hit* will take. The performance for an update or delete of an item in the hash is equivalent to this case.

Note that these statistics are summary only. Actual performance will depend on real hit/miss ratios accessing the hash. If you are concerned by hit ratios you are recommended to "oversize" your hash by using something like:

With $k chosen carefully, and likely to be a small number like 1 or 2. In theory the larger the bucket array the less chance of collision.

Stores an alias to a variable in a hash instead of copying the value.

As of Perl 5.18 every hash has its own hash traversal order, and this order changes every time a new element is inserted into the hash. This functionality is provided by maintaining an unsigned integer mask (U32) which is xor'ed with the actual bucket id during a traversal of the hash buckets using keys(), values() or each().

You can use this subroutine to get and set the traversal mask for a specific hash. Setting the mask ensures that a given hash will produce the same key order. Note that this does not guarantee that two hashes will produce the same key order for the same hash seed and traversal mask, items that collide into one bucket may have different orders regardless of this setting.

This function behaves the same way that scalar(%hash) behaved prior to Perl 5.25. Specifically if the hash is tied, then it calls the SCALAR tied hash method, if untied then if the hash is empty it return 0, otherwise it returns a string containing the number of used buckets in the hash, followed by a slash, followed by the total number of buckets in the hash.

This function returns the count of used buckets in the hash. It is expensive to calculate and the value is NOT cached, so avoid use of this function in production code.

This function returns the total number of buckets the hash holds, or would hold if the array were created. (When a hash is freshly created the array may not be allocated even though this value will be non-zero.)

# Operating on references to hashes.

Most subroutines documented in this module have equivalent versions that operate on references to hashes instead of native hashes. The following is a list of these subs. They are identical except in name and in that instead of taking a %hash they take a $hashref, and additionally are not prototyped.

Note that the trapping of the restricted operations is not atomic: for example

leaves the %hash empty rather than with its original contents.

The interface exposed by this module is very close to the current implementation of restricted hashes. Over time it is expected that this behavior will be extended and the interface abstracted further.

Michael G Schwern <[email protected]> on top of code by Nick Ing-Simmons and Jeffrey Friedl.

hv_store() is from Array::RefElem, Copyright 2000 Gisle Aas.

Additional code by Yves Orton.

Description of hash_value($string, $seed) by Christopher Yeleighton <[email protected]>

Scalar::Util , List::Util and "Algorithmic Complexity Attacks" in perlsec .

Hash::Util::FieldHash .

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 Hash Howto

Initialize a hash, initialize a hash reference, clear (or empty) a hash, clear (or empty) a hash reference, add a key/value pair to a hash, add several key/value pairs to a hash, copy a hash, delete a single key/value pair, perform an action on each key/value pair in a hash, get the size of a hash, use hash references, create a hash of hashes; via references, function to build a hash of hashes; return a reference, access and print a reference to a hash of hashes, function to build a hash of hashes of hashes; return a reference, access and print a reference to a hash of hashes of hashes, print the keys and values of a hash, given a hash reference, determine whether a hash value exists, is defined, or is true.

This how-to comes with no guaratees other than the fact that these code segments were copy/pasted from code that I wrote and ran successfully.

Assigning an empty list is the fastest way.

For a hash reference (aka hash_ref or href), assign a reference to an empty hash.

The great thing about this is that if before performing an actual assignment, you want to determine (using the ref operator) the type of thingy that a reference is pointing to, you can!... and you can expect it to be a HASH built-in type, because that is what the line above initializes it to be.

If you treat the variable just as any scalar variable; and use the my declaration alone, or assign a value, ref will return the empty string.

If you literally want to empty the contents of a hash:

In the solutions below, quotes around the keys can be omitted when the keys are identifiers.

Hash reference:

The following statements are equivalent, though the second one is more readable:

The solution differs for a hash and a hash reference, but both cases can use the delete function.

The actions below print the key/value pairs.

Use each within a while loop. Note that each iterates over entries in an apparently random order, but that order is guaranteed to be the same for the functions keys and values .

A hash reference would be only slightly different:

Use keys with a for loop.

The following two solutions are equivalent, except for the way the look. In my opinion the second approach is clearer.

Let's say we execute an sql query where some of the resulting values may be NULL. Before attempting to use any of the values we should first check whether they are defined, as in the following code. Note that the subroutine sql_fetch_hashref() takes care of connecting to the database, preparing the statement, executing it, and returning the resulting row as a hash reference using DBI's fetchrow_hashref() method.

The for loop made a new hash of only defined key/value pairs.

Alex BATKO <abatko AT cs.mcgill.ca>

Thanks to all those who have written with suggestions and comments.

Hi! If this document helped you figure out something you were stuck on; if it saved you time; if it relieved some frustration or anxiety... please consider donating. Thank you kindly!

Perhaps you are looking for web hosting? Hands down, the best web host I have ever experienced is DreamHost: http://www.dreamhost.com/r.cgi?177526 They offer everything unlimited: storage, bandwidth, domains, subdomains, email accounts, MySQL databases. As well, they permit full shell access on Debian GNU/Linux. And they are employee owned and operated since 1997. Oh, and their web control panel is amazing! Use the URL above and the following promo code to save up to $47: ABATZPH5050

http://www.cs.mcgill.ca/~abatko/computers/programming/perl/howto/

http://alex.exitloop.ca/abatko/computers/programming/perl/howto/

Sustainability Party of Canada

•   AUTHORS
•   CATEGORIES
• #   TAGS

How Hashes Really Work

Oct 1, 2002 by Abhijit Menon-Sen

It’s easy to take hashes for granted in Perl. They are simple, fast, and they usually “just work,” so people never need to know or care about how they are implemented. Sometimes, though, it’s interesting and rewarding to look at familiar tools in a different light. This article follows the development of a simple hash class in Perl in an attempt to find out how hashes really work.

A hash is an unordered collection of values, each of which is identified by a unique key. A value can be retrieved by its key, and one can add to or delete from the collection. A data structure with these properties is called a dictionary, and some of the many ways to implement them are outlined below.

Many objects are naturally identified by unique keys (like login names), and it is convenient to use a dictionary to address them in this manner. Programs use their dictionaries in different ways. A compiler’s symbol table (which records the names of functions and variables encountered during compilation) might hold a few hundred names that are looked up repeatedly (since names usually occur many times in a section of code). Another program might need to store 64-bit integers as keys, or search through several thousands of filenames.

How can we build a generally useful dictionary?

Implementing Dictionaries

One simple way to implement a dictionary is to use a linked list of keys and values (that is, a list where each element contains a key and the corresponding value). To find a particular value, one would need to scan the list sequentially, comparing the desired key with each key in turn until a match is found, or we reach the end of the list.

This approach becomes progressively slower as more values are added to the dictionary, because the average number of elements we need to scan to find a match keeps increasing. We would discover that a key was not in the dictionary only after scanning every element in it. We could make things faster by performing binary searches on a sorted array of keys instead of using a linked list, but performance would still degrade as the dictionary grew larger.

If we could transform every possible key into a unique array index (for example, by turning the string “red” into the index 14328.), then we could store each value in a corresponding array entry. All searches, insertions and deletions could then be performed with a single array lookup, irrespective of the number of keys. But although this strategy is simple and fast, it has many disadvantages and is not always useful.

For one thing, calculating an index must be fast, and independent of the size of the dictionary (or we would lose all that we gained by not using a linked list). Unless the keys are already unique integers, however, it isn’t always easy to quickly convert them into array indexes (especially when the set of possible keys is not known in advance, which is common). Furthermore, the number of keys actually stored in the dictionary is usually minute in comparison to the total number of possible keys, so allocating an array that could hold everything is wasteful.

For example, although a typical symbol table could contain a few hundred entries, there are about 50 billion alphanumeric names with six or fewer characters. Memory may be cheap enough for an occasional million-element array, but 50 billion elements (of which most remain unused) is still definitely overkill.

(Of course, there are many different ways to implement dictionaries. For example, red-black trees provide different guarantees about expected and worst-case running times, that are most appropriate for certain kinds of applications. This article does not discuss these possibilities further, but future articles may explore them in more detail.)

What we need is a practical compromise between speed and memory usage; a dictionary whose memory usage is proportional to the number of values it contains, but whose performance doesn’t become progressively worse as it grows larger.

Hashes represent just such a compromise.

Hashes are arrays (entries in it are called slots or buckets), but they do not require that every possible key correspond directly to a unique entry. Instead, a function (called a hashing function) is used to calculate the index corresponding to a particular key. This index doesn’t have to be unique, i.e., the function may return the same hash value for two or more keys. (We disregard this possibility for a while, but return to it later, since it is of great importance.)

We can now look up a value by computing the hash of its key, and looking at the corresponding bucket in the array. As long as the running time of our hashing function is independent of the number of keys, we can always perform dictionary operations in constant time. Since hashing functions make no uniqueness guarantees, however, we need some way to to resolve collisions (i.e., the hashed value of a key pointing to an occupied bucket).

The simple way to resolve collisions is to avoid storing keys and values directly in buckets, and to use per-bucket linked lists instead. To find a particular value, its key is hashed to find the index of a bucket, and the linked list is scanned to find the exact key. The lists are known as chains, and this technique is called chaining.

(There are other ways to handle collisions, e.g. via open addressing, in which colliding keys are stored in the first unoccupied slot whose index can be recursively derived from that of an occupied one. One consequence is that the hash can contain only as many values as it has buckets. This technique is not discussed here, but references to relevant material are included below.)

Hashing Functions

Since chaining repeatedly performs linear searches through linked lists, it is important that the chains always remain short (that is, the number of collisions remains low). A good hashing function would ensure that it distributed keys uniformly into the available buckets, thus reducing the probability of collisions.

In principle, a hashing function returns an array index directly; in practice, it is common to use its (arbitrary) return value modulo the number of buckets as the actual index. (Using a prime number of buckets that is not too close to a power of two tends to produce a sufficiently uniform key distribution.)

Another way to keep chains remain short is to use a technique known as dynamic hashing: adding more buckets when the existing buckets are all used (i.e., when collisions become inevitable), and using a new hashing function that distributes keys uniformly into all of the buckets (it is usually possible to use the same hashing function, but compute indexes modulo the new number of buckets). We also need to re-distribute keys, since the corresponding indices will be different with the new hashing function.

Here’s the hashing function used in Perl 5.005:

More recent versions use a function designed by Bob Jenkins, and his Web page (listed below) does an excellent job of explaining how it and other hashing functions work.

Representing Hashes in Perl

We can represent a hash as an array of buckets, where each bucket is an array of [$key, $value] pairs (there’s no particular need for chains to be linked lists; arrays are more convenient). As an exercise, let us add each of the keys in %example below into three empty buckets.

We end up with the following structure (you may want to verify that the keys are correctly hashed and distributed), in which we can identify any key-value pair in the hash with one index into the array of buckets and a second index into the entries therein. Another index serves to access either the key or the value.

Building Toy Hashes

In this section, we’ll use the representation discussed above to write a tied hash class that emulates the behavior of real Perl hashes. For the sake of brevity, the code doesn’t check for erroneous input. My comments also gloss over details that aren’t directly relevant to hashing, so you may want to have a copy of perltie handy to fill in blanks.

(All of the code in the class is available at the URL mentioned below.)

We begin by writing a tied hash constructor that creates an empty hash, and another function to empty an existing hash.

For convenience, we also write a function that looks up a given key in a hash and returns the indices of its bucket and the correct entry within. Both indexes are undefined if the key is not found in the hash.

The lookup function makes it easy to write EXISTS , FETCH , and DELETE methods for our class:

STORE is a little more complex. It must either update the value of an existing key (which is just an assignment), or add an entirely new entry (by pushing an arrayref into a suitable bucket). In the latter case, if the number of keys exceeds the number of buckets, then we create more buckets and redistribute existing keys (under the assumption that the hash will grow further; this is how we implement dynamic hashing).

For completeness, we implement an iteration mechanism for our class. The current element in each hash identifies a single entry (by its bucket and entry indices). FIRSTKEY sets it to an initial (undefined) state, and leaves all the hard work to NEXTKEY , which steps through each key in turn.

If NEXTKEY is called with the hash iterator in its initial state (by FIRSTKEY ), it returns the first key in the first occupied bucket. On subsequent calls, it returns either the next key in the current chain, or the first key in the next occupied bucket.

The do loop at FIND_NEXT_BUCKET finds the next occupied bucket if the iterator is in its initial undefined state, or if the current entry is at the end of a chain. When there are no more keys in the hash, it resets the iterator and returns undef .

We now have all the pieces required to use our Hash class exactly as we would a real Perl hash.

Perl Internals

If you want to learn more about the hashes inside Perl, then the FakeHash module by Mark-Jason Dominus and a copy of hash.c from Perl 1.0 are good places to start. The PerlGuts Illustrated Web site by Gisle Aas is also an invaluable resource in exploring the Perl internals. (References to all three are included below.)

Although our Hash class is based on Perl’s hash implementation, it is not a faithful reproduction; and while a detailed discussion of the Perl source is beyond the scope of this article, parenthetical notes in the code above may serve as a starting point for further exploration.

Donald Knuth credits H. P. Luhn at IBM for the idea of hash tables and chaining in 1953. About the same time, the idea also occurred to another group at IBM, including Gene Amdahl, who suggested open addressing and linear probing to handle collisions. Although the term “hashing” was standard terminology in the 1960s, the term did not actually appear in print until 1967 or so.

Perl 1 and 2 had “two and a half data types”, of which one half was an “associative array.” With some squinting, associative arrays look very much like hashes. The major differences were the lack of the % symbol on hash names, and that one could only assign to them one key at a time. Thus, one would say $foo{'key'} = 1; , but only @keys = keys(foo); . Familiar functions like each , keys , and values worked as they do now (and delete was added in Perl 2).

Perl 3 had three whole data types: it had the % symbol on hash names, allowed an entire hash to be assigned to at once, and added dbmopen (now deprecated in favour of tie ). Perl 4 used comma-separated hash keys to emulate multidimensional arrays (which are now better handled with array references).

Perl 5 took the giant leap of referring to associative arrays as hashes. (As far as I know, it is the first language to have referred to the data structure thus, rather than “hash table” or something similar.) Somewhat ironically, it also moved the relevant code from hash.c into hv.c .

Nomenclature

Dictionaries, as explained earlier, are unordered collections of values indexed by unique keys. They are sometimes called associative arrays or maps. They can be implemented in several ways, one of which is by using a data structure known as a hash table (and this is what Perl refers to as a hash).

Perl’s use of the term “hash” is the source of some potential confusion, because the output of a hashing function is also sometimes called a hash (especially in cryptographic contexts), and because hash tables aren’t usually called hashes anywhere else.

To be on the safe side, refer to the data structure as a hash table, and use the term “hash” only in obvious, Perl-specific contexts.

Further Resources

Introduction to Algorithms (Cormen, Leiserson and Rivest) Chapter 12 of this excellent book discusses hash tables in detail.

The Art of Computer Programming (Donald E. Knuth)

Volume 3 (“Sorting and Searching”) devotes a section (�6.4) to an exhaustive description, analysis, and a historical perspective on various hashing techniques.

http://perl.plover.com/badhash.pl

“When Hashes Go Wrong” by Mark-Jason Dominus demonstrates a pathological case of collisions, by creating a large number of keys that hash to the same value, and effectively turn the hash into a very long linked list.

http://burtleburtle.net/bob/hash/doobs.html

Current versions of Perl use a hashing function designed by Bob Jenkins. His web page explains how the function was constructed, and provides an excellent overview of how various hashing functions perform in practice.

http://perl.plover.com/FakeHash/

This module, by Mark-Jason Dominus, is a more faithful re-implementation of Perl’s hashes in Perl, and is particularly useful because it can draw pictures of the data structures involved.

http://www.etla.org/retroperl/perl1/perl-1.0.tar.gz

It might be instructive to read hash.c from the much less cluttered (and much less capable) Perl 1.0 source code, before going through the newer hv.c .

http://gisle.aas.no/perl/illguts/hv.png

This image, from Gisle Aas’s “PerlGuts Illustrated”, depicts the layout of the various structures that comprise hashes in the core. The entire web site is a treasure trove for people exploring the internals.

http://ams.wiw.org/src/Hash.pm

The source code for the tied Hash class developed in this article.

Abhijit Menon-Sen

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 .

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.

• Installing and getting started with Perl
• The Hash-bang line, or how to make a Perl scripts executable on Linux
• Perl Editor
• How to get Help for Perl?
• Perl on the command line
• Core Perl documentation and CPAN module documentation
• POD - Plain Old Documentation
• Debugging Perl scripts
• Common Warnings and Error messages in Perl
• Prompt, read from STDIN, read from the keyboard in Perl
• Automatic string to number conversion or casting in Perl
• Conditional statements, using if, else, elsif in Perl
• Boolean values in Perl
• Numerical operators
• String operators: concatenation (.), repetition (x)
• undef, the initial value and the defined function of Perl
• Strings in Perl: quoted, interpolated and escaped
• Here documents, or how to create multi-line strings in Perl
• Scalar variables
• Comparing scalars in Perl
• String functions: length, lc, uc, index, substr
• Number Guessing game
• Scope of variables in Perl
• Short-circuit in boolean expressions
• How to exit from a Perl script?
• Standard output, standard error and command line redirection
• Warning when something goes wrong
• What does die do?
• Writing to files with Perl
• Appending to files
• Open and read from text files
• Don't Open Files in the old way
• Reading and writing binary files in Perl
• EOF - End of file in Perl
• tell how far have we read a file
• seek - move the position in the filehandle in Perl
• slurp mode - reading a file in one step
• Perl for loop explained with examples
• Perl Arrays
• Processing command line arguments - @ARGV in Perl
• How to process command line arguments in Perl using Getopt::Long
• Advanced usage of Getopt::Long for accepting command line arguments
• Perl split - to cut up a string into pieces
• How to read a CSV file using Perl?
• The year of 19100
• Scalar and List context in Perl, the size of an array
• Reading from a file in scalar and list context
• STDIN in scalar and list context
• Sorting arrays in Perl
• Sorting mixed strings
• Unique values in an array in Perl
• Manipulating Perl arrays: shift, unshift, push, pop
• Reverse Polish Calculator in Perl using a stack
• Using a queue in Perl
• Reverse an array, a string or a number
• The ternary operator in Perl
• Loop controls: next, last, continue, break
• min, max, sum in Perl using List::Util
• qw - quote word
• Subroutines and functions in Perl
• Passing multiple parameters to a function in Perl
• Variable number of parameters in Perl subroutines
• Returning multiple values or a list from a subroutine in Perl
• Understanding recursive subroutines - traversing a directory tree
• Hashes in Perl
• Creating a hash from an array in Perl
• Perl hash in scalar and list context
• exists - check if a key exists in a hash
• delete an element from a hash
• How to sort a hash in Perl?
• Count the frequency of words in text using Perl
• Introduction to Regexes in Perl 5
• Regex character classes
• Regex: special character classes
• Perl 5 Regex Quantifiers
• trim - removing leading and trailing white spaces with Perl
• Perl 5 Regex Cheat sheet
• What are -e, -z, -s, -M, -A, -C, -r, -w, -x, -o, -f, -d , -l in Perl?
• Current working directory in Perl (cwd, pwd)
• Running external programs from Perl with system
• qx or backticks - running external command and capturing the output
• How to remove, copy or rename a file with Perl
• Reading the content of a directory
• Traversing the filesystem - using a queue
• Download and install Perl
• Installing a Perl Module from CPAN on Windows, Linux and Mac OSX
• How to change @INC to find Perl modules in non-standard locations
• How to add a relative directory to @INC
• How to replace a string in a file with Perl
• How to read an Excel file in Perl
• How to create an Excel file with Perl?
• Sending HTML e-mail using Email::Stuffer
• Perl/CGI script with Apache2
• JSON in Perl
• Simple Database access using Perl DBI and SQL
• Reading from LDAP in Perl using Net::LDAP
• Global symbol requires explicit package name
• Variable declaration in Perl
• Use of uninitialized value
• Barewords in Perl
• Name "main::x" used only once: possible typo at ...
• Unknown warnings category
• Can't use string (...) as an HASH ref while "strict refs" in use at ...
• Symbolic references in Perl
• Can't locate ... in @INC
• Scalar found where operator expected
• "my" variable masks earlier declaration in same scope
• Can't call method ... on unblessed reference
• Argument ... isn't numeric in numeric ...
• Can't locate object method "..." via package "1" (perhaps you forgot to load "1"?)
• Useless use of hash element in void context
• Useless use of private variable in void context
• readline() on closed filehandle in Perl
• Possible precedence issue with control flow operator
• Scalar value ... better written as ...
• substr outside of string at ...
• Have exceeded the maximum number of attempts (1000) to open temp file/dir
• Use of implicit split to @_ is deprecated ...
• Multi dimensional arrays in Perl

Multi dimensional hashes in Perl

• Minimal requirement to build a sane CPAN package
• Statement modifiers: reversed if statements
• What is autovivification?
• Formatted printing in Perl using printf and sprintf
• Data::Dumper

Explanation

Creating the third hash, traversing the hashes manually, less than two dimensions, more than two dimensions, mixed dimensions, checking if a key exists, other examples.

• Hash of arrays
• Hash of hashes of arrays

Published on 2013-11-14

Author: Gabor Szabo

• about the translations
• exists, delete in hash - video
• Hash of Arrays in Perl
• Printing hash of hashes of arrays by the array
• Always use strict!

• Trending Now
• Foundational Courses
• Data Science
• Practice Problem
• Machine Learning
• System Design
• DevOps Tutorial
• Sorting Hash in Perl
• Perl - Creating a Hash from an Array
• Perl | Useful Hash functions
• Perl | Multidimensional Hashes
• Perl | Hash in Scalar and List Context
• Perl | Searching in a File using regex
• Modes of Writing a Perl Code
• Function Signature in Perl
• Perl | goto statement
• Encryption and Decryption In Perl
• Coercions in Perl
• Perl | each() Function
• Perl | Hash Operations
• Perl | References
• Perl Tutorial - Learn Perl With Examples
• Perl | given-when Statement
• Plain Old Text Documentation in Perl Programming
• Perl | Displaying Variable Values with a Debugger

Perl | Hashes

Set of key/value pair is called a Hash. Each key in a hash structure are unique and of type strings. The values associated with these keys are scalar . These values can either be a number, string or a reference. A Hash is declared using my keyword. The variable name is preceded by the dollar sign($) followed by key under curly braces and the value associated with the key. Each key is associated with a single value. Example:

Question arises when to use Array and when to use Hashes?  

• If the things are in order, then go for the array. For Example:  
• If the things we have are not in order then go for Hashes. For example:

Empty Hash: A hash variable without any key is called empty hash .

• Example:  
• Here rateof is the hash variable.

Inserting a key/value pair into a Hash: Keys are always of string type and values always of scalar type.  

• Here the key is mango and value is 45.

Initialization of Hash & Fetching an element of a Hash: A hash variable can be initialized with key/value pairs during its declaration time. There are two ways to initialize a hash variable. One is using => which is called the fat arrow or fat comma . The second one is to put the key/value pairs in double quotes(“”) separated by a comma(,) . Using fat commas provide an alternative as you can leave double quotes around the key.  To access the individual elements from a hash you can use a dollar sign($) followed by a hash variable followed by the key under curly braces. While accessing the key/value pair if you passed the key that doesn’t present in it then it will return an undefined value or if you switched on the warning it will show the warning.  

• Output:   

Time Complexity: O(1) Auxiliary Space: O(1)

• Explanation: To access three keys Mango, Orange, Grapes and to print the values associated with it just use the dollar sign followed by Key. The print statement will print the value associated with that key.

Empty values in a Hash: Generally, you can’t assign empty values to the key of the hash. But in Perl, there is an alternative to provide empty values to Hashes. By using undef function. “undef” can be assigned to new or existing key based on the user’s need. Putting undef in double quotes will make it a string not an empty value.

• Output:  

Iterating over hashes: To access the value in a hash user must the know the key associate to that value. If the keys of a hash are not known prior then with the help of keys function, user can get the list of keys and can iterate over those keys. Example:  

Size of a hash: The number of key/value pairs is known as the size of hash. To get the size, the first user has to create an array of keys or values and then he can get the size of the array.  

• Syntax:  
• Example:   

Adding and Removing Elements in Hashes: User can easily add a new pair of key/values into a hash using simple assignment operator. 

• Example 1: Addition of element in hash 
• Example 2: Deleting an element from hash using delete function 

Please Login to comment...

Similar reads.

• Perl-hashes
• How to Use ChatGPT with Bing for Free?
• 7 Best Movavi Video Editor Alternatives in 2024
• How to Edit Comment on Instagram
• 10 Best AI Grammar Checkers and Rewording Tools
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

How To Use Perl Data Structures For Efficient Programming

Understand Perl data structures in a practical light! Get to grips with arrays, hashes, complex structures, references, and their manipulation. Concrete examples connect theory with real-world coding scenarios.

Harnessing the potential of Perl relies heavily on understanding its unique data structures. This knowledge unlocks the ability to handle complex tasks efficiently, and manage data in a sophisticated way. Let's explore the vast landscape of arrays, hashes, and more, and see how they can shape your code to be more expressive and efficient.

Understanding Perl Data Structures

Arrays in perl, hashes in perl, complex data structures in perl, using references in perl, manipulating arrays and hashes, real-world examples of data structures in perl, frequently asked questions, complex data structures.

A scalar in Perl represents a single value. It can hold numbers, strings, or references.

For example:

Arrays in Perl are ordered lists of scalars, accessed by numeric index. An array variable in Perl starts with the @ symbol.

Hashes , or associative arrays, hold pairs of items where each pair consists of a key and a value. They're often used for lookups, where a key is used to find a corresponding value.

To represent more complex data , Perl allows the creation of data structures using references. A reference is, simply put, the address of another variable. With references, we can create multi-dimensional arrays and hashes, and even combinations of both.

Accessing Array Elements

Modifying array elements, adding and removing elements, array length, array slicing.

Individual elements of an array are accessed using the array variable name followed by the index of the element in square brackets.

You can change the value of an element in an array by using its index.

To add elements to an array, you can use the push() function to add at the end, or unshift() function to add at the beginning.

To remove elements , use the pop() function to remove from the end, or shift() function to remove from the beginning.

The length of an array can be determined using the scalar function. This gives the total number of elements in the array.

Perl allows you to get a subset of an array using a range of indices. This is known as array slicing .

For those who want to know more about Perl Arrays here's an extensive tutorial:

Accessing Hash Elements

Adding and modifying hash elements, removing hash elements, keys and values functions, checking existence of a key.

Individual elements of a hash can be accessed using the hash variable name followed by the key in curly braces.

Adding elements to a hash or modifying existing ones is simple. Just associate a key with a value using the assignment operator.

You can remove elements from a hash using the delete function .

The keys function gives you all the keys in a hash, and the values function gives all the values.

The exists function allows you to check if a key is present in a hash.

For those who want to know more about Perl Hashes here's an extensive tutorial:

Dereferencing

Multi-dimensional arrays, hashes of arrays and hashes.

A reference in Perl is a scalar variable that " points to " or " refers to " the location of another value, typically an array or a hash.

To access the original array or hash from a reference, you need to dereference it. This is done by preceding the reference variable with the @ or % symbol, depending on the type of the referred data.

A multi-dimensional array is an array of arrays. You can create it by assigning references of arrays to another array.

To access elements in a multi-dimensional array, you can use multiple indices .

Just as with arrays, you can have hashes where each value is a reference to another array or hash.

Creating References

Dereferencing references, anonymous arrays and hashes, accessing elements through references, nested data structures.

You can create a reference by prefixing a variable with a backslash.

To access the original variable from the reference, we need to dereference it. This is done by prefixing the reference with the correct symbol, such as @ for arrays and % for hashes.

Perl allows the creation of anonymous arrays or hashes, which are data structures that are referenced from the moment of creation.

To access elements in an array or hash through their references , we use the arrow operator -> .

References allow for nested data structures , like an array of hashes or a hash of arrays.

For those who want to know more about Perl Reference here's an extensive tutorial:

Array Manipulation

Hash manipulation, sorting arrays and hashes.

You can add elements to an array using push to add at the end, or unshift to add at the beginning.

To remove elements, use pop to remove from the end, or shift to remove from the beginning.

Adding elements to a hash is as simple as assigning a value to a new key.

Arrays can be sorted using the sort function . By default, it sorts in ascending ASCII order, but a custom comparison can be provided.

Sorting a hash typically involves sorting the keys first, and then accessing the values in that order.

Phone Directory

Data analysis, web scraping, e-commerce inventory.

An application as simple as a phone directory can be implemented using Perl hashes . Each person's name acts as a unique key with the associated phone number as its value.

Arrays in Perl are frequently used in data analysis tasks . For instance, an array could hold a series of temperature readings that need to be processed.

Web scraping often involves handling complex data structures . A Perl script might scrape a webpage and store the data in a hash, with each key being a different section of the webpage.

In an e-commerce scenario , a hash of arrays can store inventory. The hash keys could represent product categories, with each associated value being an array of products in that category.

How is an array different from a hash in Perl?

An array is an ordered list of scalar values that are accessed by a numeric index. A hash, on the other hand, is an unordered set of key-value pairs. You can think of a hash as a dictionary, where you use a unique key instead of an index to retrieve values.

What is a reference in Perl and why is it used?

A reference is a scalar value that "points to" another value or a data structure. References are used for creating complex data structures like multidimensional arrays and for passing arrays and hashes to subroutines.

Can we manipulate arrays and hashes in Perl?

Yes, Perl provides numerous built-in functions to manipulate arrays and hashes. You can add, remove, or modify elements; sort arrays and hashes; join arrays; and perform various other operations.

Where can we apply Perl data structures in real-world scenarios?

Perl data structures are versatile and can be used in many real-world applications. For instance, arrays can be used in data analysis or machine learning for storing data points. Hashes are commonly used in database operations, where each key-value pair can represent a row of data.

Let’s test your knowledge!

What is the primary use of arrays in Perl?

Subscribe to our newsletter, subscribe to be notified of new content on marketsplash..

• Generative AI
• Office Suites
• Collaboration Software
• Productivity Software
• Augmented Reality
• Emerging Technology
• Remote Work
• Artificial Intelligence
• Operating Systems
• IT Leadership
• IT Management
• IT Operations
• Cloud Computing
• Computers and Peripherals
• Data Center
• Enterprise Applications
• Vendors and Providers
• United States
• Netherlands
• United Kingdom
• New Zealand
• Newsletters
• Foundry Careers
• Terms of Service
• Privacy Policy
• Cookie Policy
• Copyright Notice
• Member Preferences
• About AdChoices
• E-commerce Affiliate Relationships
• Your California Privacy Rights

Our Network

• Network World

What is Perl-6?

If you interact with the Perl community (via usenet or various Web

sites) then you’ve probably heard about Perl-6 by now. But what exactly

is it? Just another step in the versioning scheme or something more? I

can’t tell you exactly what Perl-6 will eventually look like, but I can

tell you what it is and why.

The change from Perl4 to Perl5 was essentially Larry Wall’s rewrite of

Perl, and quite a bit was added to the Perl language at the time (but

not much of the Perl4 language was changed). Perl-6 is to be, in

Larry’s words, “The community’s rewrite of Perl”.

Why rewrite Perl? Primarily, rewriting the core of perl (that’s the

perl source code, not the Perl language) will make it cleaner, faster,

more extensible, easier for people to understand, and more accessible

to other people who can then participate in the maintenance and

development of perl itself. Larry also decided that there is no time

like the present to investigate changes to the language itself. What

isn’t working out as well as we hoped? What additions would be useful?

Thus, the Perl6 RFC process began and the greater Perl community

submitted some 361 RFCs for language changes and/or additions.

Not all of the requests will be integrated into Perl-6 of course, but

Larry and the team of Perl-6 developers will sift through them and use

some in the new design. The process will take some time and you

shouldn’t expect to see a usable Perl-6 for perhaps another year.

However, a few changes are apparent already:

* Changing the usage of type symbols for variables

* A new dereference operator (and concatenation operator)

* Arrays and Hashes in scalar context

* Typed variables?

Changing the Usage of Type Symbols for Variables

Currently, as I’m sure you well know by now, we have three type symbols

for variables: $ for scalars, @ for arrays, and % for hashes. However,

you also know that these are symbols not strictly applied to variables,

but to the type of thing you want to access. For example, to obtain the

scalar value at index 3 of an array you use the $ symbol:

print $array[3];

In Perl-6 these type symbols will be exclusively used with their

variable types, not the data type being accessed — thus, the

following will be the correct syntax:

$scalar = 12;

@array = (1,2,3);

%hash = (name => ‘andrew’, beer => ‘dark ale’);

@slice = @array[1,2];

$scalar = @array[0];

%hash{‘age’,’children’} = (37, 2);

print %hash{name};

As you can see, no matter what type of value you access you will use

the variable type symbol (no more using @ for slices of hashes, and $

for scalar access of single array or hash elements).

A New Dereference Operator (and Concatenation Operator)

The -> dereference arrow will be replaced with a dot (.). This makes

Perl more similar to other OO languages with respect to calling object

$foo = SomeObject->new();

$foo->some_method();

$foo = SomeObject.new();

$foo.some_method();

This means that the dot will no longer be used as the concatenation

operator — the new concat op will likely be the ~ character.

Typed Variables?

Yes, you will have the ability to declare variables as certain types

(such as ‘int’ or ‘constant’), or dimensioning arrays to a certain

size. You won’t be required to do this sort of thing, but it allows

perl to optimize the code if you do.

Arrays and Hashes in Scalar Context

When used in a scalar context, hashes and arrays will return a

reference to themselves. This means, to assign a reference to a hash or

array we can do the following:

$a_ref = @array;

$h_ref = %hash;

But, don’t worry about your habit of getting the length (number of

elements) of an array by using it in scalar context, because now, an

array reference in numerical context will return its length, and will

return true if it holds any elements in a boolean context, so we can

still perform the same sorts of array testing as we do now.

As you can see even from this short foray, Perl-6 won’t simply be

adding new stuff for us to use, but will be changing some of our

currently familiar syntax. This is not a bad thing. The changes

proposed so far make a good deal of sense and we should not fear them

merely because we will have to make some adjustments to they way we

currently do things. Also be aware that there will be some sort of

compatibility mode so that Perl-5 programs can still be run (not to

mention that versions of Perl-5 will not be disappearing anytime soon

There is a good more information about Perl-6, and you can stay abreast

of its progress by checking out the following two sites:

http://www.perl.org/perl6/

http://dev.perl.org/perl6/

Next Week: Named parameters for subroutine calls.

Related content

Windows 11: a guide to the updates, windows 10: a guide to the updates, intel unveils its ai roadmap, chips to rival nvidia, windows 11 insider previews: what’s in the latest build, from our editors straight to your inbox, show me more, google sheets power tips: how to use dropdown lists.

Office 365: A guide to the updates

Yes, Apple’s Vision Pro is an enterprise product

Voice cloning, song creation via AI gets even scarier

The link between smartphones and social media addiction

Sam Bankman-Fried gets 25 years in prison