Come posso gestire il ciclo annidato senza annidare le istruzioni foreach in Perl?

Question

Ho uno script Perl che annida i cicli foreach come mostrato di seguito. Ci vuole molto tempo:

#! /usr/bin/perl 

use strict; 
use warnings; 

my @sites = ('a', 'b', 'c'); 
my @servers = ('A', 'B'); 
my @data_type = ("X", "Y", "Z"); 

foreach my $site (@sites) { 
    foreach my $server_type (@servers) { 
     foreach my $data (@data_type) { 
      #statements 
     } 
    } 
} 

Nesting foreach dichiarazioni come questo richiede molto tempo ed è difficile da leggere e non molto carina. Qualcuno può suggerire un modo migliore per codificare questa struttura usando gli hash o qualche altra struttura intelligente?

Answer 1

non vedo che cosa il vostro problema è, ma è possibile utilizzare un prodotto cartesiano generica se siete abituati a SQL o qualcosa del genere:

sub cartesian { 
    my @C = map { [ $_ ] } @{ shift @_ }; 
    foreach (@_) { 
     my @A = @$_; 
     @C = map { my $n = $_; map { [ $n, @$_ ] } @C } @A; 
    } 
    return @C; 
} 

my @sites = ('a', 'b', 'c'); 
my @servers = ('A', 'B'); 
my @data_type = ("X", "Y", "Z"); 

foreach (cartesian(\@sites, \@servers, \@data_type)) { 
    ($data, $server_type, $site) = @$_; 
    print "$site $server_type $data\n"; 
} 

Answer 2

foreach è preferibile perché è leggibile. Che cosa intendi esattamente per "ogni array può causare problemi" (quali problemi?) E "i valori possono non corrispondere" (quali valori?)

Answer 3

L'unica preoccupazione che posso avere quando si utilizzano i cicli annidati è una certa ambiguità in quello che è $_ . Considerando che non lo stai nemmeno usando, non penso che ci sia un modo migliore per fare quello che vuoi.

Come sidenote, vorrei aggiungere che $_ è ben definito in questo caso, ma come programmatore potrei non voler affrontare il sovraccarico di ricordare a che punto si riferisce ad ogni passaggio.

Hai qualche problema con lo specifico?

Answer 4

È possibile utilizzare un classico for ciclo, invece.

for(my $i = 0; $i <= $#sites; $i++){ 
    for(my $j = 0; $j <= $#servers; $j++){ 
     for(my $k = 0; $k <= $#data_type; $k++){ 
      do_functions ... 

Ma questo lascia ancora i problemi e le discrepanze a cui si stava rivolgendo. Ti suggerisco di gestire questi problemi nella parte do_functions.

Answer 5

Si potrebbe semplicemente utilizzare for.

(mi dispiace, non poteva resistere)

Answer 6

Se ho capito la tua domanda correttamente allora si chiede come utilizzare hash con foreach per evitare discordanze che si avrebbe nel tuo esempio di matrice ?.

Se è così allora qui è un esempio:

use strict; 
use warnings; 

my %sites = (

    a => { 
     A => { 
      data_type => [ 'X', 'Y' ], 
     } 
    }, 

    b => { 
     B => { 
      data_type => [ 'Y', 'Z' ], 
     } 
    }, 

    c => { 

    }, 
); 

for my $site (keys %sites) { 
    for my $server (keys %{ $sites{ $site } }) { 
     for my $data (keys %{ $sites{ $site }{ $server } }) { 
      my @data_types = @{ $sites{ $site }{ $server }{ data_type } }; 
      say "On site $site is server $server with $data @data_types"; 
     } 
    } 
} 

È anche possibile utilizzare mentre & ciascuno che fa produce codice più facile per gli occhi:

while (my ($site, $site_info) = each %sites) { 
    while (my ($server, $server_info) = each %{ $site_info }) { 
     my @data_types = @{ $server_info->{data_type} }; 
     say "On site $site we have server $server with data types @data_types" 
      if @data_types; 
    } 
} 

noti inoltre ho rimosso ultimo ciclo nell'esempio sopra perché è attualmente superfluo con i miei dati hash di esempio.

NB. Se hai intenzione di modificare le chiavi o interrompere il ciclo, ti preghiamo di leggere su each e come influenza l'iterazione.

PS. Questo esempio non riguarda il ciclo, ma i dati vengono rappresentati al meglio come Hash e non come Array! (anche se non è chiaro al 100% dalla domanda che è così!).

Answer 7

Utilizzare il modulo Set::CrossProduct o utilizzare Algorithm::Loops.Non dovresti creare strutture nidificate e codificate per affrontare questi problemi. Entrambi i moduli possono farlo per te per un numero arbitrario di array.

use Set::CrossProduct; 

my @sites = ('a', 'b', 'c'); 
my @servers = ('A', 'B'); 
my @data_type = ("X", "Y", "Z"); 

my $cross = Set::CrossProduct->new( 
    [ \@sites, \@servers, \@data_type ] 
    ); 

while(my $tuple = $cross->get) { 
    print "@$tuple\n"; 
    } 

Non solo, ma il cursore si dà modi per spostarsi nella iteratore in modo da non è necessario limitarsi alla combinazione corrente. È possibile esaminare le combinazioni precedenti e successive, che potrebbero essere utili per i limiti (come quando la tupla successiva è un server diverso).

Attenzione per le persone che desiderano creare tutte le combinazioni in memoria. Non c'è nemmeno bisogno di farlo.