sub sorted_keys_by_value {
  my $hash = shift;
  return sort {$hash->{$a} cmp $hash->{$b}} keys %$hash;
}

@sorted_keys = sorted_keys_by_value(\%myHash);
[download]

-- Mike

--
just,my${.02}

Tie::SortHash may be what you want here.

 use Tie::SortHash;


my %people = (
                'John Doe'  => 33,
                'Jane Doe'  => 29,
                'Jim Smith' => 15,
               );


my $sortblock = q(
                    my $c = (split /\s+/, $a)[1];
                    my $d = (split /\s+/, $b)[1];


$c cmp $d
                              ||
                    $hash{$a} <=> $hash{$b}
                   );


tie %people, 'Tie::SortHash', \%people, $sortblock;


foreach my $name ( keys %people ) {
    print $name . " is " . $people{$name} . " years old.\n";
  }


# This output will always be
  Jane Doe is 29 years old.
  John Doe is 33 years old.
  Jim Smith is 15 years old.
[download]

sub sortByValue {
  my %hash = @_;
  sort { $a->[1] cmp $b->[1] }
    map { [ $_, %hash{$_} ] } 
      keys %hash;
}

foreach $pair (sortByBalue %myHash) {
    print "$pair->[0] - $pair->[1]\n";
}
[download]

sub sortByValue {
  my %hash = @_;
  sort { $hash{$a} cmp $hash{$b} } keys %hash;
}

foreach my $key (sortByValue %myHash) {
  print "$key - $myHash{$key}\n";
}
[download]

my $current_href = {};
sub byValue {
  $current_href->{$a} cmp $current_href->{$a};
}
# ... somewhere in your program
$current_href = \%myHash;
[download]

Just assign hash ref to current hash in consideration

Courage, the Cowardly Dog.

Being a Perl newbie, I must ask,
why is this "not good to use in programs"?

I beleive it's better to create "independent" subroutines, in that sence of a word that they will not depend on a state of some external global variable. When you'll return to this subroutine after many years and will reuse it, then you have a chance to use it incorrectly.

As a second point, you may accidentially break that external variable somehow and after that something bad will happen, including coredumps (AFAIK some versions of perl will coredump on sort routines when criteria subroutine does not behave well)

Courage, the Cowardly Dog

key_val(%whatever_hash_name_you_want_);
sub key_val {
my %hash = shift;
map {print "$_ - $hash{$_} \n";} sort{$hash{$a} cmp $hash{$b}} keys %h
+ash;
}
[download]

use Carp;

sub make_by_value_sorter {
    my ($hash, $op) = @_;

    return sub ($$) { $hash->{$_[0]} <=> $hash->{$_[1]} }
        if $op eq '<=>';
    return sub ($$) { $hash->{$_[0]} cmp $hash->{$_[1]} }
        if $op eq 'cmp';

    croak("Unknown sort op '$op'");
}

my $hash = {
    bar => 1,
    foo => 2,
    baz => 3,
    fah => 4,
};

my $by_value = make_by_value_sorter($hash, '<=>');

my @a = sort $by_value keys %$hash; # Simple case
my @b = sort {
    substr($a, 0, 1) cmp substr($b, 0, 1)
    or $by_value->($a, $b) # As part of another sort sub
} keys %$hash;
[download]

Stick your code that you've defined into a Perl subroutine that takes in a hash. Then you can call that subroutine each time you want to perform your algorithm. By the way, you don't need to define the byValue subroutine. Perl lets you use an anynomous subroutine right in the sort statement.

The syntax of using the anynomous subroutine in the sort operation is:

    sort BLOCK LIST
[download]

Sticking the code you want to use over again into a subroutine that takes in a hash causes your hashes to get copies into that local hash in the subroutine you've written each time it's called. That local hash copy in the subroutine gets defined by using my, not by using local, which may seem confusing. Here's the code, hope it helps.

#!perl

use strict;

&main();

sub main {
    my %hash1 = ( "george" => "salsa",
                  "doug"   => "apple",
                  "steve"  => "cantaloupe",
                  "alex"    => "blueberry",
                  "andrew"  => "ginger" );

    my %hash2 = ( "william" => "cats",
                  "robert"  => "dogs",
                  "randy"   => "birds",
                  "phillip" => "fish" );

    my %hash3 = ( "amy"        => "swims",
                  "georgianne" => "runs",
                  "susan"      => "jogs",
                  "stephanie"  => "walks",
                  "sarah"      => "bicycles",
                  "debbie"     => "dances" );

    print "The result of calling hash_value_sort on \%hash1 is\n";
    &hash_value_sort( %hash1 );

    print "\n";

    print "The result of calling hash_value_sort on \%hash2 is\n";
    &hash_value_sort( %hash2 );

    print "\n";

    print "The result of calling hash_value_sort on \%hash3 is\n";
    &hash_value_sort( %hash3 );

    print "\n";

    my @keys_sorted_by_value1 = &get_sorted_keys( %hash1 );
    my @keys_sorted_by_value2 = &get_sorted_keys( %hash2 );
    my @keys_sorted_by_value3 = &get_sorted_keys( %hash3 );

    print ( "The keys of \%hash1 sorted by their values are: ", ( join
+( ", ", @keys_sorted_by_value1 ) ), "\n" );
    print ( "The keys of \%hash2 sorted by their values are: ", ( join
+( ", ", @keys_sorted_by_value2 ) ), "\n" );
    print ( "The keys of \%hash3 sorted by their values are: ", ( join
+( ", ", @keys_sorted_by_value3 ) ), "\n" );

    print "\n";

    return;
}

sub hash_value_sort {
    my %h = ( @_ );

    my $key;

    foreach $key ( sort { $h{$a} cmp $h{$b} } keys %h ) {
        print "$key - $h{$key}\n";
    }

    return;
}

sub get_sorted_keys {
    my %h = ( @_ );

    return sort { $h{$a} cmp $h{$b} } keys %h;
}
[download]

use strict; # never forget ;-)
foreach my $key (sort values %hash) { .... }

This won't give you the hash keys sorted by value (what the original poster wanted)... it will give you a sorted list of the hash values. The variable name $key is misleading, and should probably be changed to $value.

-- Mike

--
just,my${.02}