|
|
|
6.2. Hash Element AccessTo access an element of a hash,use syntax that looks like this: $hash{$some_key} This is similar to what we used for array access,but here we use curly braces instead of square brackets around the subscript (key).[*] That key expression is now a string,rather than a number:
$family_name{"fred"} = "flintstone";
$family_name{"barney"} = "rubble"; Figure 6-3 shows how the resulting hash keys are assigned.
Figure 6-3. Assigned hash keys
This lets us use code like this: foreach $person (qw< barney fred >) {
print "I've heard of $person $family_name{$person}./n";
} The name of the hash is like any other Perl identifier (letters,digits,and underscores,but it can't start with a digit). And it's from a separate namespace; that is,there's no connection between the hash element $family_name{"fred"} and a subroutine &family_name,for example. Of course,there's no reason to confuse everyone by giving everything the same name. But Perl won't mind if you have a scalar called $family_name and array elements like $family_name[5]. We humans will have to do as Perl does; we'll have to look to see what punctuation appears before and after the identifier to see what it means. When there is a dollar sign in front of the name and curly braces afterward,it's a hash element that's being accessed. When choosing the name of a hash,it's often nice to think of the word "for" between the name of the hash and the key. As in,"the family_name for fred is flintstone." So,the hash is named family_name,and the relationship between the keys and their values becomes clear. The hash key may be any expression and not just the literal strings and scalar variables that we're showing here: $foo = "bar";
print $family_name{ $foo . "ney" }; # prints "rubble" When you store something into an existing hash element,it overwrites the previous value: $family_name{"fred"} = "astaire"; # gives new value to existing element
$bedrock = $family_name{"fred"}; # gets "astaire"; old value is lost That's analogous to what happens with arrays and scalars; if you store something new into $pebbles[17] or $dino,the old value is replaced. If you store something new into $family_name{"fred"},the old value is replaced as well. Hash elements spring into existence by assignment: $family_name{"wilma"} = "flintstone"; # adds a new key (and value)
$family_name{"betty"} .= $family_name{"barney"}; # creates the element if needed That's like what happens with arrays and scalars; if you didn't have $pebbles[17] or $dino before,you will have it after you assign to it. If you didn't have $family_name{"betty"} before,you do now. Accessing outside the hash gives undef: $granite = $family_name{"larry"}; # No larry here: undef This is like what happens with arrays and scalars; if there's nothing yet stored in $pebbles[17] or $dino,accessing them will yield undef. If there's nothing yet stored in $family_name{"larry"},accessing it will yield undef. 6.2.1. The Hash as a WholeTo refer to the entire hash,use the percent sign ("%") as a prefix. The hash we've been using for the last few pages is actually called %family_name. For convenience,a hash may be converted into a list and back again. Assigning to a hash (in this case,the one from Figure 6-1) is a list-context assignment,where the list is made of key/value pairs:[*]
%some_hash = ("foo",35,"bar",12.4,2.5,"hello","wilma",1.72e30,"betty","bye/n"); The value of the hash (in a list context) is a list of key/value pairs: @any_array = %some_hash; We call this unwinding the hashturning it back into a list of key/value pairs. The pairs won't necessarily be in the same order as the original list: print "@any_array/n";
# might give something like this:
# betty bye (and a newline) wilma 1.72e+30 foo 35 2.5 hello bar 12.4 The order is jumbled because Perl keeps the key/value pairs in an order that's convenient for Perl so it can look up any item quickly. You use a hash when you don't care what order the items are in or when you have an easy way to put them into the order you want. Though the order of the key/value pairs is jumbled,each key "sticks" with its corresponding value in the resulting list. So,though we don't know where the key foo will appear in the list,we know that its value,35,will be right after it. 6.2.2. Hash AssignmentIt's rare to do so,but a hash may be copied using this syntax: %new_hash = %old_hash; This is more work for Perl than meets the eye. Unlike what happens in languages like Pascal or C,where such an operation would copy a block of memory,Perl's data structures are more complex. So,that line of code tells Perl to unwind the %old_hash into a list of key/value pairs and assign those to %new_hash,building it up one key/value pair at a time. Transforming the hash in some way is more common. For example,we could make an inverse hash: %inverse_hash = reverse %any_hash; This takes %any_hash and unwinds it into a list of key/value pairs,making a list like (key,value,key,...). Then,reverse turns that list end-for-end,making a list like (value,...). The keys are where the values used to be,and the values are where the keys used to be. When that's stored into %inverse_hash,we'll be able to look up a string that was a value in %any_hash,because it's now a key of %inverse_hash. And the value we'll find is one that was one of the keys from %any_hash. This gives us a way to look up a "value" (now a key),and find a "key" (now a value). You might guess (or determine from scientific principles if you're clever) that this will work properly only if the values in the original hash are unique; otherwise,we'd have duplicate keys in the new hash,and keys are always unique. Here's the rule that Perl uses: the last one in wins. That is,the later items in the list overwrite any earlier ones. We don't know what order the key/value pairs will have in this list,so there's no telling which ones will win. You'd use this technique only if you know there are no duplicates among the original values.[*] But that's the case for the IP address and hostname examples given earlier:
%ip_address = reverse %host_name; We can look up a hostname or IP address with equal ease to find the corresponding IP address or hostname. 6.2.3. The Big ArrowWhen assigning a list to a hash,sometimes it's not obvious which elements are keys and which are values. For example,in this assignment (which we saw earlier),we have to count through the list,saying,"key,value,key,value..." to determine whether 2.5 is a key or a value: %some_hash = ("foo","bye/n"); Wouldn't it be nice if Perl gave us a way to pair up keys and values in that kind of a list so we could easily see see which ones were which? Larry thought so,too,which is why he invented the big arrow,(=>).[*] To Perl,it's just a different way to "spell" a comma,so it's also sometimes called the "fat comma." In the Perl grammar,any time that you need a comma ( , ),you can use the big arrow instead; it's all the same to Perl.[
my %last_name = ( # a hash may be a lexical variable
"fred" => "flintstone","dino" => undef,"barney" => "rubble","betty" => "rubble",); Here,it's easy (or perhaps at least easier) to see whose name pairs with which value even if we end up putting many pairs on one line. And notice the extra comma at the end of the list. As we saw earlier,this is harmless but convenient; if we need to add additional people to this hash,we'll simply make sure that each line has a key/value pair and a trailing comma. Perl will see that there is a comma between each item and the next,and one extra (harmless) comma at the end of the list.
|
|
|
|
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。