¿Cómo puedo manejar el bucle anidado sin anidar las instrucciones foreach en Perl?

Question

Tengo un script Perl que anida los bucles foreach como se ve a continuación. Se tarda mucho tiempo:

#! /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 
     } 
    } 
} 

foreach declaraciones de anidamiento como esto lleva mucho tiempo y es difícil de leer y no muy bonita. ¿Alguien puede sugerir una mejor manera de codificar esta estructura usando hash o alguna otra estructura inteligente?

Answer 1

no veo cuál es tu problema, pero se puede usar un producto cartesiano genérico si está acostumbrado a SQL o algo:

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 es preferible porque es legible. ¿A qué se refiere exactamente con "cada arreglo puede causar problemas" (¿qué problemas?) Y "los valores pueden no coincidir" (¿qué valores?)

Answer 3

La única preocupación que podría surgir al utilizar bucles anidados es cierta ambigüedad en lo que $_ es . Considerando que ni siquiera lo está usando, no creo que haya una mejor manera de hacer lo que quiere.

Como nota al margen, me gustaría añadir que $_ está bien definido en este caso, pero como programador no me gustaría tratar con la sobrecarga de recordar a qué se refiere en cada paso.

¿Tiene alguna pregunta acerca de con el código?

Answer 4

Usted puede utilizar un bucle clásico for lugar.

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

Pero eso aún deja los problemas y desajustes a los que se estaba refiriendo. Le sugiero que maneje estos problemas en la parte do_functions.

Answer 5

Simplemente puede usar for.

(lo siento, no pudo resistir)

Answer 6

Si entiendo bien su pregunta, entonces preguntar cómo utilizar los hashes con foreach para evitar desajustes que tendría en su matriz de ejemplo ?.

Si es así, entonces aquí es un ejemplo:

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"; 
     } 
    } 
} 

También puede utilizar mientras & cada uno, que hace produce código más fácil en el ojo:

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; 
    } 
} 

También tenga en cuenta Quité último bucle en el ejemplo anterior porque actualmente es superfluo con mis datos hash de ejemplo.

NB. Si planea enmendar claves o salir del bucle, lea en each y cómo afecta la iteración.

PS. ¡Este ejemplo no se trata del bucle, sino de que los datos se representan mejor como Hash y no como Array! (aunque no está claro al 100% de la pregunta, eso es así!).

Answer 7

Utilice mi módulo Set::CrossProduct, o use Algorithm::Loops.No debería tener que crear estructuras anidadas y codificadas para tratar estos problemas. Ambos módulos pueden hacerlo por usted para un número arbitrario de matrices.

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"; 
    } 

No sólo eso, sino que el cursor le da maneras de desplazarse por el iterador por lo que no tiene por qué limitarse a la combinación actual. Puede inspeccionar las combinaciones anterior y siguiente, que pueden ser útiles para los límites (como cuando la siguiente tupla es un servidor diferente).

Tenga cuidado con las personas que desean crear todas las combinaciones en la memoria. No hay necesidad de hacer eso tampoco.