Strategie per il paramento dei parametri

2

I metodi con molti parametri sono spesso a volte inevitabili. Nella mia esperienza personale trovo spesso questo il caso per i punti di ingresso del programma e le complesse procedure matematiche - dove il refactoring non è possibile o oscurerebbe il significato del metodo. Sebbene non ci siano limiti concreti per il numero di parametri che un metodo potrebbe avere, è palesemente indesiderabile scrivere / mantenere / vedere i metodi con un gran numero di parametri.

Un'alternativa è il wrapping dei parametri nelle classi. Questo ha alcuni chiari vantaggi , tra cui:

  • Più facile per gli occhi; a nessuno piace la pesca dei parametri.
  • Manutenzione più semplice; la modifica dei parametri non richiede modifiche alla dichiarazione del metodo.
  • Migliore digitazione; avvolgere i relativi parametri in un unico tipo può aiutare a chiarire il significato della funzione.

Tuttavia, ci sono diversi svantaggi in questo approccio:

  • Scrittura peggiore; i parametri di accoppiamento che non si adattano naturalmente possono essere fuorvianti.
  • Il sovraccarico diventa impossibile o disordinato.
  • Può imporre tipi stranieri indesiderati agli utenti.
  • Può portare alla pigrizia.

Ad esempio: ho visto spesso codice Python in cui l'autore passa ripetutamente attorno agli oggetti generati da optparse (o argparse ) mentre utilizza solo un piccolo sottoinsieme dei parametri in ciascun metodo.

Per brevità, ecco le opzioni:

my_method(Param1 a, Param2 b, Param3 c, ...., ParamInf zzz)
my_method(Params params)
my_method(Param1 a, Param2 b, Param3 c, SomeParams the_rest)
my_method(ParamSetA a, ParamSetB b, ...)

Sebbene si tratti di un argomento alquanto soggettivo, sono interessato a conoscere le strategie per trattare i metodi con un gran numero di parametri. Gli esempi di vita reale, in particolare quelli sottoposti a revisione del codice, sarebbero particolarmente utili.

    
posta Daniel 23.01.2015 - 17:13
fonte

2 risposte

7

Methods with many parameters are often unavoidable.

Da quando?

Voglio dire che potrebbe essere inevitabile avere un paio di metodi come questo in una base di codice non banale, ma la vasta maggioranza dei tuoi metodi avrà uno o due parametri.

Avere una barca di parametri è un segno che:  1. La tua funzione sta facendo troppo.  2. Il carico della tua barca di parametri separati è molto più coeso di quanto pensassi.

Il modo in cui risolvi il problema dipende da quale segno è applicabile. Se la tua funzione sta facendo troppo, allora suddividerla creerà naturalmente meno parametri, anche se una funzione di orchestrazione ne ha troppi. Il codice più isolato rende anche più facile vedere cosa sta succedendo per semplificare ulteriormente.

Se i tuoi parametri sono più coesivi, allora è meglio aggregarli (o almeno alcuni di essi) in un utile pacchetto / classe / struttura poiché sarebbe usato al di fuori di questa sola funzione.

Ma almeno personalmente, trovo che gli oggetti parametro siano vili. Se i parametri sono coesivi, dovrebbero essere stati in una classe dall'inizio. Se li stai trasformando in una classe "per rendere questa funzione più carina", allora ti manca il punto. Risolvi il problema, non il sintomo.

    
risposta data 23.01.2015 - 17:31
fonte
6

Il fattore chiave qui è quanto coesistono i parametri.

Se hai un gruppo di parametri logicamente raggruppati e dovrebbe appartenere a una classe, allora crea una classe per loro. Se si verificano insieme negli elenchi di parametri ma non sono raggruppati in modo logico, tenerli separati.

Mantieni questo metodo così com'è:

function getDistance(Point p1, Point p2) { ... }

Questo potrebbe essere meglio servito con un oggetto per raggruppare i parametri:

function manufacture(Make make, Model model, Year year) { ... }

Questi parametri funzionano tutti insieme per descrivere qualcosa:

class VehicleDescriptor {
  Make make;
  Model model;
  Year year;
}

function manufacture(VehicleDescriptor v) { ... }
    
risposta data 23.01.2015 - 19:24
fonte

Leggi altre domande sui tag