Dovrei evitare nidificare le istruzioni in Perl?

Question

Sto facendo un po 'di Perl e vedere le mie dichiarazioni "se" nidificate mi sta facendo impazzire. Sono riuscito a ridurre alcuni di loro con blocchi di guardia in un'altra sezione, ma sono bloccato qui.

Pensi che possa lasciare il codice così com'è, oppure esiste un modo "corretto" di rifattorizzare quanto segue? (Ammetto anche di essere relativamente nuovo a Perl)

Questa è in realtà una subroutine che richiede l'input dell'utente su ciascun parametro di una lista (file esterno). $ [3] è il modello di corrispondenza, $ [2] è il valore predefinito per il parametro considerato (NULL se non ce n'è), $ _ [1] specifica se è obbligatorio o meno. la frase 'next' si riferisce al prossimo parametro read (while loop).

Con l'aiuto di tutti (grazie!), Ecco la versione più recente.

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

Ecco una versione leggermente più leggibile del caos risposta:

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

I punti chiave sono:

• Non è necessario altro se si sta uscendo l'anello di corrente con successivo
• I casi eccezionali devono essere gestiti per primi
• È possibile Migliorare notevolmente la leggibilità utilizzando variabili denominate

Answer 2

Se logica necessaria nidificato if allora credo che non v'è nulla di sbagliato con loro.

Tuttavia, si potrebbe migliorare la leggibilità del codice

1. Utilizzando solo un po 'più spazio bianco e
2. Utilizzando le proprie variabili invece di operare direttamente sul @_

Isn' questo è un po 'più leggibile?

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

È prassi comune definire le costanti per gli indici di array e assegnare loro nomi significativi. Come ad esempio:

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

Per quanto riguarda la nidificazione - Si dovrebbe spesso cercare di ridurre il trattino (cioè mantenendo il livello di nidificazione basso), ma mai farlo a scapito di mantenere il codice comprensibile. Non ho alcun problema con il livello di nidificazione, ma questo è anche solo un piccolo taglio del codice. Se è davvero un problema, puoi suddividere le condizioni in subroutine separate.

Answer 4

Dato che probabilmente fare uno spaghetti goto altrimenti Assolutamente No.

Quale potrebbe essere migliore è 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

si potrebbe semplificare a quanto segue se non ti piace tutto il resto.

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 preoccupazione principale è mantenere il codice leggibile.

Se è possibile ottenere codice leggibile con istruzioni nidificate if, procedere. Ma mantenere il buon senso attivo in ogni momento.

Answer 8

suppongo che si possa fare combinazioni logiche di appiattire fuori:

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; 

allora si potrebbe utilizzare un interruttore per renderlo un po 'meglio.

Answer 9

Penso che la principale (se non solo) ragione per le preoccupazioni relative al nesting è la complessità dell'algoritmo. Negli altri casi dovresti preoccuparti della leggibilità e della manutenibilità, che possono essere affrontate con commenti e rientri propoer.

trovo sempre un buon esercizio di mantenibilità per leggere vecchio codice di mine, non solo per un feedback sulla leggibilità, ma anche sulla tecnica ...

Answer 10

Un approccio alternativo che a volte aiuta con la leggibilità è quello di mettere alcuni o tutti dei rami in riferimenti di codice ben definiti. Ecco un inizio sull'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...