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.
Solution
my %hash = ();
For a hash reference (aka hash_ref or href), assign a reference to an empty hash.
Solution
my $hash_ref = {}; # ref will return 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.
Note
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.
my $hash_ref; # not a hash ref!... just a scalar
my $hash_ref = 0; # zero
If you literally want to empty the contents of a hash:
Solution
for (keys %hash)
{
delete $hash{$_};
}
Solution
for (keys %$href)
{
delete $href->{$_};
}
Example
#!/usr/bin/perl
use strict; # use all three strictures
$|++; # set command buffering
use Data::Dumper;
use feature 'say';
my $hash_ref1 = { 1=> 1 };
my $hash_ref2 = $hash_ref1;
print "hash_ref1 $hash_ref1\n";
print "hash_ref2 $hash_ref2\n"; # same, same
say Dumper($hash_ref1);
say Dumper($hash_ref2); # same, same
$hash_ref1->{2} = 2;
say Dumper($hash_ref1);
say Dumper($hash_ref2); # same, same
#$hash_ref1 = {}; # if you did this instead of the for-loop, hash_ref2 would be different
for (keys %$hash_ref1)
{
delete $hash_ref1->{$_};
}
print "hash_ref1 $hash_ref1\n";
print "hash_ref2 $hash_ref2\n"; # same, same?
say Dumper($hash_ref1);
say Dumper($hash_ref2); # same, same?
Output
hash_ref1 HASH(0x100804ed0)
hash_ref2 HASH(0x100804ed0)
$VAR1 = {
'1' => 1
};
$VAR1 = {
'1' => 1
};
$VAR1 = {
'1' => 1,
'2' => 2
};
$VAR1 = {
'1' => 1,
'2' => 2
};
hash_ref1 HASH(0x100804ed0)
hash_ref2 HASH(0x100804ed0)
$VAR1 = {};
$VAR1 = {};
In the solutions below, quotes around the keys can be omitted when the keys are identifiers.
Hash:
Solution
$hash{ 'key' } = 'value'; # hash
$hash{ $key } = $value; # hash, using variables
Hash reference:
Solution
$href->{ 'key' } = 'value'; # hash ref
$href->{ $key } = $value; # hash ref, using variables
Solution
The following statements are equivalent, though the second one is more readable:
%hash = ( 'key1', 'value1', 'key2', 'value2', 'key3', 'value3' );
%hash = (
key1 => 'value1',
key2 => 'value2',
key3 => 'value3',
);
Solution
my %hash_copy = %hash; # copy a hash
my $href_copy = $href; # copy a hash ref
The solution differs for a hash and a hash reference, but both cases can use the delete function.
Solution
Hash:
delete $hash{$key};
Hash reference:
delete $hash_ref->{$key};
The actions below print the key/value pairs.
Solution
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.
while ( my ($key, $value) = each(%hash) ) {
print "$key => $value\n";
}
A hash reference would be only slightly different:
while ( my ($key, $value) = each(%$hash_ref) ) {
print "$key => $value\n";
}
Solution
Use keys with a for loop.
for my $key ( keys %hash ) {
my $value = $hash{$key};
print "$key => $value\n";
}
Example
my $file = $ARGV[0] || "-";
my %from = ();
open FILE, "< $file" or die "Can't open $file : $!";
while( <FILE> ) {
if (/^From: (.*)/) { $from{$1}++ } # count recurrences of sender
}
close FILE;
for my $sender ( sort keys %from ) {
print "$sender: $from{$sender}\n";
}
Solution
print "size of hash: " . keys( %hash ) . ".\n";
Solution
my $i = 0;
$i += scalar keys %$hash_ref; # method 1: explicit scalar context
$i += keys %$hash_ref; # method 2: implicit scalar context
Solution
sub foo
{
my $hash_ref;
$hash_ref->{ 'key1' } = 'value1';
$hash_ref->{ 'key2' } = 'value2';
$hash_ref->{ 'key3' } = 'value3';
return $hash_ref;
}
my $hash_ref = foo();
print "the keys... ", sort keys %$hash_ref, "...\n";
The following two solutions are equivalent, except for the way the look. In my opinion the second approach is clearer.
Solution
$requiredPatches_href->{ $patch }->{ os } = $os;
$requiredPatches_href->{ $patch }->{ arch } = $arch;
$requiredPatches_href->{ $patch }->{ info } = $info;
Solution
$requiredPatches_href->{ $patch } = {
os => $os,
arch => $arch,
info => $info,
};
Solution
sub foo
{
my ( $login, $p, $uid, $gid, $gecos, $dir, $s );
my %HoH = ();
my $file = '/etc/passwd';
open( PASSWD, "< $file" ) or die "Can't open $file : $!";
while( <PASSWD> ) {
( $login, $p, $uid, $gid, $gecos, $dir, $s ) = split( ':' );
$HoH{ $login }{ 'uid' } = $uid;
$HoH{ $login }{ 'gid' } = $gid;
$HoH{ $login }{ 'dir' } = $dir;
}
close PASSWD;
return \%HoH;
}
Solution
my $rHoH = foo();
my( $uid, $gid, $dir );
for my $login ( keys %$rHoH ) {
$uid = $rHoH->{ $login }->{ 'uid' }; # method 1 most readable
$gid = ${ $rHoH->{ $login } }{ 'gid' }; # method 2
$dir = ${ ${ $rHoH }{ $login } }{ 'dir' }; # method 3 least readable
print "uid: $uid, gid: $gid, dir, $dir.\n";
}
Solution
my $rHoH = foo();
for my $k1 ( sort keys %$rHoH ) {
print "k1: $k1\n";
for my $k2 ( keys %{$rHoH->{ $k1 }} ) {
print "k2: $k2 $rHoH->{ $k1 }{ $k2 }\n";
}
}
Solution
sub foo
{
my %HoHoH = ();
while( ... ) {
if( /LOCATION:/ ) {
...
} elsif( /MODULE:/ ) {
$HoHoH{ $loc }{ $module_type }{ MODULE_NAME } = $module_name;
} elsif( $ARGS_ALLOWED ) {
$HoHoH{ $loc }{ $module_type }{ $arg_name } = $arg_value;
}
}
return \%HoHoH;
}
Solution
my $rHoHoH = foo();
for my $k1 ( sort keys %$rHoHoH ) {
print "$k1\n";
for my $k2 ( sort keys %{$rHoHoH->{ $k1 }} ) {
print "\t$k2\n";
for my $k3 ( sort keys %{$rHoHoH->{ $k1 }->{ $k2 }} ) {
print "\t\t$k3 => $rHoHoH->{ $k1 }->{ $k2 }->{ $k3 }\n";
}
}
}
Solution
while( my ($k, $v) = each %$hash_ref ) {
print "key: $k, value: $v.\n";
}
Solution
print "Value EXISTS, but may be undefined.\n" if exists $hash{ $key };
print "Value is DEFINED, but may be false.\n" if defined $hash{ $key };
print "Value is TRUE at hash key $key.\n" if $hash{ $key };
Example
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.
my $answers = 'a,b,c,d,e';
my $sql = "select max_time, $answers from questions " .
'where question_number=?';
my $hash_ref = sql_fetch_hashref( $sql, $q );
my @answers = split ',', $answers;
my $max_time = $hash_ref->{max_time} || '60';
my $hash_ref_ans;
for my $letter ( @answers ) {
$hash_ref_ans->{ $letter } = $hash_ref->{ $letter }
if defined $hash_ref->{ $letter };
}
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/