I have a hash that holds for each record an anonymous hash with 2 elements: an array and a hash. I want to initialize this subsidiary hash with a list of keys.
I know hash slices can be used when you use a normal hash (not a ref) and use both a key list and values list.
My code is like this
my %records;
my $key = "key1";
my #states = ( "state1", "state2", "state3" );
$records{$key} = {
numbers => [],
states => %{#states} #This is wrong !
};
EDIT (marked as duplicate): This question asks how to add multiple keys to an anonymous hash.
It's puzzling that you have only keys for your hash and no values. This code will set the value of each element of $records{$key}{states} to undef
my %records;
my $key = "key1";
my #states = ( "state1", "state2", "state3" );
$records{$key} = {
numbers => [],
states => { map { ( $_ => undef ) } #states },
};
But it would be clearer to build a proper hash temporarily and assign a reference to it to the data structure. I've enclosed the entire assignment process in its own block so that I can declare a temporary lexical hash %states
{
my %states;
#states{#states} = ();
$records{$key} = {
numbers => [],
states => \%states,
};
}
But note that it's generally better if hash elements don't exist at all rather than create them with undefined values. There is no need to preallocate the elements of a hash like this, just leave it empty like you did with the array
$records{$key} = {
numbers => [],
states => {},
}
Related
I have a Perl data structure, loaded from a json, with Data::Dumper looking like this:
$VAR1 = {
'Stat' => [
{
'statCfgFile' => 'statcfg_0001.json',
'statid' => 1,
'status' => 'running',
'something' => 'other'
},
{
'statCfgFile' => 'statcfg_0002.json',
'statid' => 2,
'status' => 'running'
'something' => 'other'
}
]
}
From another dataset, I get a statid to read the hash, but the given id does not match the array key, therefore I need to go into deep, reading the statid property.
Of course, I could loop through the array, but with a large array list, that might hit performance.
Is there a way to directly access the array element by the statid stored in the hash?
As the data model is in my hands and currently in development:
Would it be better not to use an array, but also a hash with the statid as the naming element?
The short answer is no, you can't pull a value out of an array based on a criteria without iterating over the array. But there are ways to write it without using a loop.
Say the data structure is $data and you want to pull hashes where statid equals $id_to_find.
my #matching_hashes = grep {$_->{statid} = $id_to_find}} #{$data->{Stat}};
If only the first hash matching the ID is relevant, you could use the core module List::Util function first, which does the same thing as grep but only returns the first match instead of a list. It would be faster than grep because it stops iterating over the array as soon as it finds one match.
use List::Util 'first';
my $matching hash = first {$_->{statid} = $id_to_find}} #{$data->{Stat}};
As you indicated, using hash lookups is much faster than list operations. You could create a hash index of array adresses. Note this still requires you iterate over the array once.
# create the index;
my %index;
my #array = #{$data->{Stat}};
for my $address (0..$#array) { # "$#array" is the last element of #array
my $hash = $array[$address];
my $id = $hash->{statid};
$index{$id} = $address; # now you can use an ID to get the array address
}
# use the index
my $id_to_find = 42;
my $wanted_array_address = $index{$id_to_find};
my $matching_hash = $data->{Stat}->[$wanted_array_address];
If the statid field is unique then I suggest you use something more like this
{
1 => 'statcfg_0001.json',
2 => 'statcfg_0002.json',
}
The hash includes more data than shown. I extend the example
Then you need a hash instead of just a string value for each statid
{
1 => {
statCfgFile => 'statcfg_0001.json',
statid => 1,
status => 'running',
something => 'other',
},
2 => {
statCfgFile => 'statcfg_0002.json',
statid => 2,
status => 'running',
something => 'other',
},
}
I am trying to merge two hashes. But they are return values from functions. How can I dereference the return values inline? I don't want to use extra variables such as my $pos = makePos();
use v5.8.8;
use strict;
use warnings;
sub _makePos
{
my $desc= {
pos50 => {unit => 'm', desc => 'position error' },
pos95 => {unit => 'm', desc => '95% position error' }
};
return $desc;
}
sub _makeVel
{
my $desc= {
vel50 => {unit => 'm/s', desc => 'velocity error' },
vel95 => {unit => 'm/s', desc => '95% velocity error' }
};
return $desc;
}
my $descs = {_makePos(), _makeVel()};
use Data::Dumper;
print Dumper($descs);
this prints only the hash returned from _makeVel. how does it work?
$VAR1 = {
'HASH(0x21ea4a0)' => {
'vel50' => {
'desc' => 'velocity error',
'unit' => 'm/s'
},
'vel95' => {
'unit' => 'm/s',
'desc' => '95% velocity error'
}
}
};
changing this line as
my $descs = {%{_makePos()}, %{_makeVel()}};
worked!
Actually, your original solution did print both of the hashes, but the first one was "stringified" as it was being used as the key of your hash. It's there as HASH(0x21ea4a0).
I see you have a solution, but it might be worth explaining what was going wrong and why your solution fixed it.
Your two subroutines don't return hashes but, rather, hash references. A hash reference is a scalar value that is, effectively, a pointer to a hash.
A hash is created from a list of values. Your code that creates your news hash (actually, once again, a hash reference) is this:
my $descs = {_makePos(), _makeVel()};
This is two scalar values. The first is used as a key in the new hash and the second is used as the associated value - hence the results you get from Data::Dumper.
What you actually want to do is to "dereference" your hashes and get back to the actual hashes. You can dereference a hash using the syntax %{ ... }, where the ... is any expression returning a hash reference. And that's what you've done in your solution. You dereference the hash references, which gives you a list of key/value pairs. The pairs from the two dereferenced hashes are then joined together in a single list which is used to create your new, combined, hash.
I should point out that there's a danger in this approach. If your two subroutines can ever return references to hashes that contain the same key, then only one version of that repeated key will appear in the combined hash.
$hash = { 'Man' => 'Bill',
'Woman' => 'Mary,
'Dog' => 'Ben'
};
What exactly do Perl's “anonymous hashes” do?
It is a reference to a hash that can be stored in a scalar variable. It is exactly like a regular hash, except that the curly brackets {...} creates a reference to a hash.
Note the usage of different parentheses in these examples:
%hash = ( foo => "bar" ); # regular hash
$hash = { foo => "bar" }; # reference to anonymous (unnamed) hash
$href = \%hash; # reference to named hash %hash
This is useful to be able to do, if you for example want to pass a hash as an argument to a subroutine:
foo(\%hash, $arg1, $arg2);
sub foo {
my ($hash, #args) = #_;
...
}
And it is a way to create a multilevel hash:
my %hash = ( foo => { bar => "baz" } ); # $hash{foo}{bar} is now "baz"
You use an anonymous hash when you need reference to a hash and a named hash is inconvenient or unnecessary. For instance, if you wanted to pass a hash to a subroutine, you could write
my %hash = (a => 1, b => 2);
mysub(\%hash);
but if there is no need to access the hash through its name %hash you could equivalently write
mysub( {a => 1, b => 2} );
This comes in handy wherever you need a reference to a hash, and particularly when you are building nested data structures. Instead of
my %person1 = ( age => 34, position => 'captain' );
my %person2 = ( age => 28, position => 'boatswain' );
my %person3 = ( age => 18, position => 'cabin boy' );
my %crew = (
bill => \%person1,
ben => \%person2,
weed => \%person3,
);
you can write just
my %crew = (
bill => { age => 34, position => 'captain' },
ben => { age => 28, position => 'boatswain' },
weed => { age => 18, position => 'cabin boy' },
);
and to add a member,
$crew{jess} = { age => 4, position => "ship's cat" };
is a lot neater than
my %newperson = ( age => 4, position => "ship's cat" );
$crew{jess} = \%newperson;
and of course, even if a hash is created with a name, if its reference is passed elsewhere then there may be no way of using that original name, so it must be treated as anonymous. For instance in
my $crew_member = $crew{bill}
$crew_member is now effectively a reference to an anonymous hash, regardless of how the data was originally constructed. Even if the data is (in some scope) still accessible as %person1 there is no general way of knowing that, and the data can be accessed only by its reference.
It's quite simple. They allow you to write
push #hashes, { ... };
f(config => { ... });
instead of
my %hash = ( ... );
push #hashes, \%hash;
my %config = ( ... );
f(config => \%config);
(If you want to know the purpose of references, that's another story entirely.)
Anything "anonymous" is a data structure that used in a way where it does not get a name.
Your question has confused everyone else on this page, because your example shows you giving a name to the hash you created, thus it is no longer anonymous.
For example - if you have a subroutine and you want to return a hash, you could write this code:-
return {'hello'=>123};
since it has no name there - it is anonymous. Read on to unwind the extra confusion other people have added on this page by introducing references, which are not the same thing.
This is another anonymous hash (an empty one):
{}
This is an anonymous hash with something in it:
{'foo'=>123}
This is an anonymous (empty) array:
[]
This is an anonymous array with something in it:
['foo',123]
Most of the time when people use these things, they are really trying to magically put them inside of other data structures, without the bother of giving them a waste-of-time temporary name when they do this.
For example - you might want to have a hash in the middle of an array!
#array=(1,2,{foo=>3});
that array has 3 elements - the last element is a hash! ($array[2]->{foo} is 3)
perl -e '#array=(1,2,{foo=>1});use Data::Dumper;print Data::Dumper->Dump([\#array],["\#array"]);'
$#array = [
1,
2,
{
'foo' => 1
}
];
Sometimes you want to don't want to pass around an entire data structure, instead, you just want to use a pointer or reference to the data structure. In perl, you can do this by adding a "\" in front of a variable;
%hashcopy=%myhash; # this duplicates the hash
$myhash{test}=2; # does not affect %hashcopy
$hashpointer=\%myhash; # this gives us a different way to access the same hash
$hashpointer->{test}=2;# changes %myhash
$$hashpointer{test}=2; # identical to above (notice double $$)
If you're crazy, you can even have references to anonymous hashes:
perl -e 'print [],\[],{},\{}'
ARRAY(0x10eed48)REF(0x110b7a8)HASH(0x10eee38)REF(0x110b808)
and sometimes perl is clever enough to know you really meant reference, even when you didn't specifically say so, like my first "return" example:
perl -e 'sub tst{ return {foo=>bar}; }; $var=&tst();use Data::Dumper;print Data::Dumper->Dump([\$var],["\$var"]);'
$var = \{
'foo' => 'bar'
};
or:-
perl -e 'sub tst{ return {foo=>bar}; }; $var=&tst(); print "$$var{foo}\n$var->{foo}\n"'
bar
bar
Which structure is created as following in Perl?
my $self = { Name => $name, Color => $class->default_color };
If it is a hash, then is the official notation not the following ( parentheses, % instead of $):
my %self = ( Name => $name, Color => $class->default_color );
The data in { ... } is a hash ref.
The data in ( ... ) is a list, but the context makes it into a hash.
Well, it's still a hash - but an anonymous one. And its reference is assigned to $self. The doc says:
A reference to an anonymous hash can be created using curly brackets:
$hashref = {
'Adam' => 'Eve',
'Clyde' => 'Bonnie',
};
Perl doesn't have a literal representation of a hash, so we create a hash as a list of key-value pairs. The anonymous hash constructor or assignment to named hash converts the list of key-value pairs to a hash.
The top line creates a hash reference which you assign to a scalar variable:
my $self = { Name => $name, Color => $class->default_color };
The bottom line assigns a list to a named hash:
my %self = ( Name => $name, Color => $class->default_color );
I am new to Perl, and can't find the answer to the question in the Learning Perl book.
For example I have a array like:
my #loop=("op1_sel","op2_sel");
and two hash table as:
my %op1_sel=(
"bibuf","000",
"self","101"
);
my %op2_sel=(
"zero","1",
"temp","0"
);
Now I want to use variables in the loop to loop for the hash table for a particular key
for example:
foreach(#loop)
{
print ${$_}{"bibuf"} ;
}
But it seems not working, I know the ${$_} part is wrong, can anyone can tell me how
to fix this ?
Use nested hashes. Like this:
my %op;
# put a hash reference into hash, twice
$op{op1_sel} = \%op1_sel;
$op{op2_sel} = \%op2_sel;
# later ...
foreach (keys %op) {
print "bibuf of $_: $op{$_}->{bibuf}\n";
};
Or, long story short, just
my %op = (
op1_sel => {
foo => 1,
bar => 2,
# ...
},
op2_sel => {
# ...
},
};
The {} construct creates a reference to anonymous hash and is the standard way of handling nested data structures.
See also perldoc perldsc.
You can't refer to lexical (my) variables using the ${$foo} syntax. You could probably make it work if they were package variables, but this would not be the right way to go about it.
The right way to do it is using a nested data structure.
I can see two obvious ways of doing it. You could either make an array of op_sel containing the inner hashes directly, or create a hash of hashes, and then index into that.
So "array of hashes":
my #op_sels = (
{
bibuf => '000',
self => '101',
},
{
zero => '1',
temp => '0',
},
);
for my $op (#op_sels) {
print $$op{bibuf};
}
and "hash of hashes":
my %op_sels = (
1 => {
bibuf => '000',
self => '101',
},
2 => {
zero => '1',
temp => '0',
},
);
for my $op_key (sort keys %op_sels) {
print $op_sels{$op_key}{bibuf};
}
You can use eval for this.
foreach(#loop)
{
eval "\%var = \%$_";
print $var{"bibuf"} ;
}