Perl - funzione integrata per "zippare" insieme due array?

Question

Voglio unire due array di uguale lunghezza in un singolo array prendendo il primo elemento dall'array A, il primo elemento dall'array B; secondo elemento da A, secondo elemento da B, ecc Il seguente programma illustra l'algoritmo:

# file zipper.pl 
use strict; 
use warnings; 
use 5.010; 

my @keys = qw/abel baker charlie dog easy fox/; 
my @values = qw/a b c d e f/; 

# ==> Is there a builtin function that is equivalent of zipper()? <== 
# 
my %hash = zipper(\@keys, \@values); 

while (my ($k, $v) = each %hash) { 
    say "$k=$v"; 
} 

# zipper(): Take two equal-length arrays and merge them (one from A, one from B, 
# another from A, another from B, etc.) into a single array. 
# 
sub zipper { 
    my $k_ref = shift; 
    my $v_ref = shift; 
    die "Arrays must be equal length" if @$k_ref != @$v_ref; 
    my $i = 0; 
    return map { $k_ref->[ $i++ ], $_ } @$v_ref; 
} 

uscita

$ ./zipper.pl 
easy=e 
dog=d 
fox=f 
charlie=c 
baker=b 
abel=a 

mi chiedo se ho trascurato una funzione built-in Perl che fai l'equivalente di zipper(). Sarà nel ciclo più interno del programma e dovrà essere eseguito il più velocemente possibile. Se non c'è un modulo built-in o CPAN, qualcuno può migliorare la mia implementazione?

Answer 1

Altri hanno dato buone risposte per lato della maglia/zip della questione, ma se si sta solo creando un hash da una serie di chiavi e uno di valori puoi farlo con poco apprezzato hash slice.

#!/usr/bin/env perl 

use strict; 
use warnings; 

my @keys = qw/abel baker charlie dog easy fox/; 
my @values = qw/a b c d e f/; 

my %hash; 
@hash{@keys} = @values; 

use Data::Dumper; 
print Dumper \%hash; 

Addendum

ho avuto modo di pensare il motivo per cui si può scegliere un metodo rispetto all'altro. Personalmente ritengo che l'implementazione della slice sia leggibile come lo zip, ma altri potrebbero non essere d'accordo. Se lo fai spesso, potresti preoccuparti della velocità, nel qual caso la forma della fetta è più veloce.

#!/usr/bin/env perl 

use strict; 
use warnings; 

use List::MoreUtils qw/zip/; 
use Benchmark qw/cmpthese/; 

my @keys = qw/abel baker charlie dog easy fox/; 
my @values = qw/a b c d e f/; 

cmpthese(100000, { 
    zip => sub { 
    my %hash = zip @keys, @values; 
    }, 
    slice => sub { 
    my %hash; 
    @hash{@keys} = @values; 
    }, 
}); 

risultati:

  Rate zip slice 
zip 51282/s -- -34% 
slice 78125/s 52% -- 

Answer 2

Dato che hai offerto un'idea CPAN, c'è List::MoreUtils e zip.

use List::MoreUtils qw(zip); 

my @keys = qw/abel baker charlie dog easy fox/; 
my @values = qw/a b c d e f/; 

my @zipped = zip @keys, @values; 

Il contenuto di @zipped sarebbero:

abel, a, baker, b, charlie, c, dog, d, easy, e, fox, f 

La parte bella sull'utilizzo di questo metodo è che si può comprimere più di due liste, se lo si desidera. Dal momento che Perl non ha il concetto di un tipo di tupla, è quasi come un'operazione di appiattimento.

Answer 3

si desidera utilizzare list :: moreutils (o di un elenco :: AllUtils) per ottenere l'accesso alla rete aka zip vedere https://metacpan.org/pod/List::MoreUtils#mesh-ARRAY1-ARRAY2-ARRAY3

Answer 4

Sebbene questa specifica funzione esiste già in List :: moreutils, è possibile utilizzare i prototipi per dare le proprie funzioni per gli array la comparsa di operatori di matrice built-in (come push, shift, pop):

sub zipper (++) { # perldoc perlsub 
    my ($k, $v) = @_; 
    die "Arrays must be equal length" if @$k != @$v; 
    my $i; 
    return map { $k->[$i++], $_ } @$v 
} 

%hash = zipper @keys, @values; 
%hash = zipper \@keys, \@values; 
%hash = zipper $key_aref, $value_aref;