Comment puis-je obtenir une partie seulement d'un hachage en Perl?

Est-il un moyen d'obtenir un sous-hash? Dois-je utiliser un hachage de la tranche?

Par exemple:

%hash = ( a => 1, b => 2, c => 3 );

Je veux seulement

%hash = ( a => 1, b => 2 );
  • Comme il n'y a rien, en toute logique, "tranche" je soupçonne que quelque chose à voir avec la 'carte'. Dans un tableau et que vous souhaitez faire sur la base d'un indice, mais dans une table de hachage n'est pas fiable représentation interne des données. Vous auriez besoin d'un certain type de qualificatif (regex?) pour définir ce qui doit aller dans le subhash et ce qui ne l'est pas.
  • BTW, vous hachage syntaxe est incorrecte: tour accolades "()" pour une plaine de hachage, "{}" pour l'anonyme de hachage références.
InformationsquelleAutor Timmy | 2009-06-11
  1. 53

    Hachage tranches retourner les valeurs associées à une liste de clés. Pour obtenir un hash tranche vous modifiez le sceau de @ et de fournir une liste de clés (dans ce cas "a" et "b"):

    my @items = @hash{"a", "b"};

    Souvent, vous pouvez utiliser une citation mot de l'opérateur de produire la liste:

    my @items = @hash{qw/a b/};

    Vous pouvez également attribuer à un hachage de la tranche, donc si vous voulez une nouvelle table de hachage qui contient un sous-ensemble d'un autre de hachage, vous pouvez dire

    my %new_hash;
@new_hash{qw/a b/} = @hash{qw/a b/};

    Beaucoup de gens vont utiliser un carte au lieu de hachage tranches:

    my %new_hash = map { $_ => $hash{$_} } qw/a b/;

    De départ avec Perl 5.20.0, vous pouvez obtenir les clés et les valeurs en une seule étape si vous utilisez le % de sigil au lieu de l' @ prefix:

    my %new_hash = %hash{qw/a b/};
    • cela rend le pourquoi de la "carte" des œuvres w/ hachages un peu plus clair pour moi. Merci
    • Larry Wall, brian d foy, et...Chas. Owens...merci pour cette explication détaillée!
    • Vous devriez probablement faire de plus en plus clair qu'un hachage tranche juste a les valeurs, pas de paires clé/valeur.
    • Êtes-vous plus heureux maintenant?
    InformationsquelleAutor Chas. Owens
  2. 9

    Vous voudrez probablement pour assembler une liste de touches que vous souhaitez:

    my @keys = qw(a b);

    Et ensuite utiliser une boucle pour faire du hash:

    my %hash_slice;
for(@keys) {
  $hash_slice{$_} = %hash{$_};
}

    Ou:

    my %hash_slice = map { $_ => $hash{$_} } @keys;

    (Ma préférence va à la seconde, mais quel que soit celui que vous aimez est la meilleure.)

    InformationsquelleAutor Chris Lutz
  3. 6

    Encore une autre façon:

    my @keys = qw(a b);
my %hash = (a => 1, b => 2, c => 3);
my %hash_copy;
@hash_copy{@keys} = @hash{@keys};
    InformationsquelleAutor Hynek -Pichi- Vychodil
  4. 3

    Trop de la programmation fonctionnelle, m'amène à penser de zip premier.

    Avec Liste::MoreUtils installé,

    use List::MoreUtils qw(zip);

%hash = qw(a 1 b 2 c 3);
@keys = qw(a b);
@values = @hash{@keys};
%hash = zip @keys, @values;

    Malheureusement, le prototype de la Liste::MoreUtils de zip inhibe

    zip @keys, @hash{@keys};

    Si vous voulez vraiment éviter la variable intermédiaire, vous pourriez

    zip @keys, @{[@hash{@keys}]};

    Ou il suffit d'écrire votre propre zip sans la problématique de prototype. (Ce qui n'a pas besoin de Liste::MoreUtils à tous.)

    sub zip {
    my $max = -1;
    $max < $#$_and $max = $#$_ for @_;
    map { my $ix = $_; map $_->[$ix], @_; } 0..$max;
}

%hash = zip \@keys, [@hash{@keys}];

    Si vous allez à la mutation en place,

    %hash = qw(a 1 b 2 c 3);
%keep = map +($_ => 1), qw(a b);
$keep{$a} or delete $hash{$a} while ($a, $b) = each %hash;

    évite la copie supplémentaire que le map et zip solutions engager. (Oui, la mutation de la table de hachage, alors que vous êtes de l'itération, c'est sûr... tant que la mutation n'est de supprimer le plus récemment réitéré paire.)

    • Expliquer cela, s'il vous plait,%keep = map +($_ => 1), qw(a b); ?
    InformationsquelleAutor ephemient
  5. 3

    FWIW, je l'utilise à l'Orignal::Autobox ici:

    my $hash = { a => 1, b => 2, c => 3, d => 4 };
$hash->hslice([qw/a b/]) # { a => 1, b => 2 };

    Dans la vraie vie, je l'utilise pour extraire le "nom d'utilisateur" et "mot de passe" à partir d'un formulaire de soumission et passer de Catalyseur du $c->authenticate (qui s'attend à ce que, dans mon cas, un hashref contenant le nom d'utilisateur et le mot de passe, mais rien d'autre).

    • Comment est $hash->hslice(qw/b/) mieux que @{$hash}{qw/b/}? Ou est-ce l'un de ces cas où, si j'ai à demander, je suis allée trop loin pour comprendre?
    • Vous devriez avoir une réponse de modèle, de sorte que "j'utilise l'Orignal::" au début de chaque réponse. 🙂
    • Chas. Owens: ce n'est pas ce hslice n'. @{$hash}{...} retourne une liste de valeurs; hslice retourne une nouvelle table de hachage de référence avec les touches du clavier et valeurs.
    InformationsquelleAutor jrockway
  6. 2

    Nouveau en perl 5.20 est de hachage tranches de la restitution des clés ainsi que les valeurs à l'aide d' % comme sur la dernière ligne ici:

    my %population = ('Norway',5000000,'Sweden',9600000,'Denmark',5500000);
my @slice_values = @population{'Norway','Sweden'}; # all perls can do this
my %slice_hash   = %population{'Norway','Sweden'}; # perl >= 5.20 can do this!
    InformationsquelleAutor Kjetil S.
  7. -3

    Une table de hachage est un non-ordonnée contenant, mais le terme de tranche n'a vraiment de sens qu'en termes d'ordre de l'conteneur. Peut-être l'aide d'un tableau. Sinon, vous pouvez juste avoir à enlever tous les éléments que vous ne voulez pas produire vos " sous-hash.

    InformationsquelleAutor B Johnson