¿Debo evitar declaraciones anidadas si en Perl?

Question

Estoy haciendo algo de Perl y ver mis declaraciones "si" anidadas me está volviendo loco. Logré reducir algunos de ellos con bloques de guardia en otra sección, pero estoy atrapado aquí.

¿Cree que puedo dejar el código como está, o existe una forma "adecuada" de refactorizar lo siguiente? (También reconozco que soy relativamente nuevo en Perl)

Esto es realmente una subrutina que solicita la entrada del usuario en cada parámetro de una lista (archivo externo). $ [3] es el patrón coincidente, $ [2] es el valor predeterminado para el parámetro considerado (NULL si no hay ninguno), $ _ [1] especifica si es obligatorio o no. la instrucción 'siguiente' se refiere al siguiente parámetro leído (while loop).

Con la ayuda de todos (gracias!), Aquí está la última versión.

100   if ($input ne '' && ($input !~ $match || $input =~ /'.+'/)) { 
101    print "! Format not respected. Match : /$match/ (without \' \')\n"; 
102    next; 
103   } 
104   if ($input eq '') { 
105    if ($default eq 'NULL') { 
106     if ($manda eq 'y') { 
107      print "! Mandatory parameter not filled in\n"; 
108      next; 
109     } 
110     print "+ Ignoring parameter.\n"; 
111     $input = ''; 
112    } 
113    else { 
114     print "+ Using default value\n"; 
115     $input = $default; 
116    } 
117   } 

---

98  if($input eq ''){ 
99    if($_[2] eq 'NULL'){ 
100     if($_[1] eq 'y'){ 
101      print "! Mandatory parameter not filled in\n"; 
102      next; 
103     } 
104     else{ 
105      print "+ Ignoring parameter.\n"; 
106      $input = ''; 
107     } 
108    } 
109    else{ 
110     print "+ Using default value\n"; 
111     $input = $_[2]; 
112    } 
113   } 
114   elsif($input !~ $_[3] || $input =~ /'.+'/){ 
115     print "! Format not respected. Match : /$_[3]/ (without \' \')\n"; 
116     next; 
117    } 
118   } 

Answer 1

Aquí es una versión ligeramente más legible del caos respuesta:

# Set sane variable names... 
my ($is_required, $default, $pattern) = @_ 

# Convert the external string convention for simpler evaluation... 
$default = undef if $default eq 'NULL' 

# Refuse problematic input before going any further... 
if ($input ne '' && $input !~ $pattern || $input =~ /'.+'/) { 
    print "! Format not respected. Match : /$pattern/ (without \' \')\n"; 
    next; 
} 


# If there was no input string... 
if($input eq '') { 

    # Set the default, if one was provided... 
    if($default) { 
     print "+ Using default value\n"; 
     $input = $default; 
    } 
    # otherwise, complain if a default was required... 
    else { 
     if($is_required eq 'y'){ 
      print "! Mandatory parameter not filled in\n"; 
      next; 
     } 
     print "+ Ignoring parameter (no input or default provided).\n"; 
    } 
} 

Los puntos clave son:

• No es necesario demás si va a salir del bucle actual con siguiente
• casos excepcionales se deben manejar primero
• Puede mejorar en gran medida la legibilidad mediante el uso de variables con nombre

Answer 2

Si lógica requerida if anidado entonces supongo que no hay nada malo con ellos.

Sin embargo, se podría mejorar la legibilidad de su código por

1. Usando sólo un poco más espacio en blanco y
2. Mediante el uso de sus propias variables en vez de operar directamente sobre @_

Isn' ¿Esto es un poco más legible?

98  if ($input eq '') { 
99    if ($default eq 'NULL'){ 
100     if ($input eq 'y'){ 
101      print "! Mandatory parameter not filled in\n"; 
102      next; 
103     } 
104     else { 
105      print "+ Ignoring parameter.\n"; 
106      $input = ''; 
107     } 
108    } 
109    else { 
110     print "+ Using default value\n"; 
111     $input = $default; 
112    } 
113   } 
114   elsif ($input !~ $foo || $input =~ /'.+'/) { 
115     print "! Format not respected. Match : /$foo/ (without \' \')\n"; 
116     next; 
117    } 
118   } 

Answer 3

La práctica común es definir constantes para sus índices de matriz y darles nombres significativos. Tales como:

use constant MANDATORY => 1, 
      DEFAULT => 2, 
      PATTERN => 3; 
... 
if($_[DEFAULT] eq 'NULL') { 
    ... 
} 

En cuanto a la jerarquización - A menudo se debe tratar de reducir el guión (que significa mantener el nivel de anidación baja), pero nunca hacerlo a expensas de mantener el código comprensible. No tengo ningún problema con el nivel de anidación, pero esto también es solo un pequeño corte de tu código. Si realmente es un problema, puede dividir las condiciones en subrutinas separadas.

Answer 4

Teniendo en cuenta que es probable que hacer un espagueti goto lo contrario, absolutamente Nº

Lo que podría ser mejor es un switch case.

Answer 5

if($input ne '' && ($input !~ $_[3] || $input =~ /'.+'/)) { 
    print "! Format not respected. Match : /$_[3]/ (without \' \')\n"; 
    next; 
} 
if($input eq '') { 
    if($_[2] eq 'NULL') { 
     if($_[1] eq 'y'){ 
      print "! Mandatory parameter not filled in\n"; 
      next; 
     } 
     print "+ Ignoring parameter.\n"; 
     $input = ''; 
    } else { 
     print "+ Using default value\n"; 
     $input = $_[2]; 
    } 
} 

Answer 6

puede simplificar a lo siguiente si no le gusta todo lo demás.

if($input eq ''){ 
    $input = $_[2]; 
    $output = "+ Using default value\n"; 
    if($_[2] eq 'NULL'){ 
     $input = ''; 
     $output = "+ Ignoring parameter.\n"; 
     if($_[1] eq 'y'){ 
      $output = "! Mandatory parameter not filled in\n"; 
     } 
    } 
} 
elsif($input !~ $_[3] || $input =~ /'.+'/){ 
    $output = "! Format not respected. Match : /$_[3]/ (without \' \')\n"; 
} 
print $output; 

Answer 7

La principal preocupación es mantener el código legible.

Si puede obtener un código legible con declaraciones if anidadas, continúe. Pero mantenga el sentido común activo todo el tiempo.

Answer 8

supongo que podría hacer combinaciones lógicas para aplanarlo:

if(($input eq '')&&($_[2] eq 'NULL')&&($_[1] eq 'y')){ 
    print "! Mandatory parameter not filled in\n"; 
    next; 
} 

elsif(($input eq '')&&($_[2] eq 'NULL')){ 
    print "+ Ignoring parameter.\n"; 
    $input = ''; 
} 

elsif($input eq ''){ 
    print "+ Using default value\n"; 
    $input = $_[2]; 
    next; 
} 


elsif($input !~ $_[3] || $input =~ /'.+'/){ 
    print "! Format not respected. Match : /$_[3]/ (without \' \')\n"; 
} 

print $output; 

entonces se podría usar un interruptor para que sea un poco mejor.

Answer 9

Creo que la razón principal (si no solo) de las preocupaciones relativas a la anidación es la complejidad del algoritmo. En los otros casos, debe preocuparse por la legibilidad y la capacidad de mantenimiento, que se puede abordar con comentarios y sangría de propoer.

siempre encuentro un buen ejercicio de maintanability para leer el código antiguo de la mina, no sólo para comentarios sobre la legibilidad, sino también en la técnica ...

Answer 10

Un enfoque alternativo que a veces ayuda a la legibilidad es poner algunos o todos de las ramas en referencias de código bien nombradas. Aquí está el comienzo de la idea:

$format_not_respected = sub { 
    return 0 if ...; 
    print "! Format not respected...."; 
    return 1; 
} 
$missing_mandatory_param = sub { 
    return 0 if ...; 
    print "! Mandatory parameter not filled in\n"; 
    return 1; 
} 

next if $format_not_respected->(); 
next if $missing_mandatory_param->(); 
etc...