Best practice: Tante piccole funzioni/metodi, o più funzioni con processo logico componenti inline?

È meglio scrivere molti metodi di piccole dimensioni (o funzioni), o semplicemente scrivere la logica di quei piccoli processi di destra, nel luogo dove si sarebbe chiamato il piccolo metodo? Che cosa circa la rottura di codice in una piccola funzione, anche se per il momento è soltanto chiamato da uno spot?

Se la scelta dipende da alcuni criteri, che cosa sono; come se un programmatore di fare un buon giudizio di chiamata?

Sto sperando che la risposta può essere applicato generalmente in molte lingue, ma, se necessario, le risposte possono essere specifici per una o più lingue. In particolare, sto pensando di SQL (funzioni, le regole e le stored procedure), Perl, PHP, Javascript, Ruby.

  • Dividere le cose aiuta la leggibilità del codice. se( la Conversione.ToBoolean(riga[“IsActive”])) è meno leggibile “if(obj.IsActive)”. 🙂
  • Hm. Relative SOF domanda: stackoverflow.com/questions/20981/…
  • Io, personalmente, non piace quando il codice è molto piccola funzioni (da 1 a 3 linee), che sono chiamati solo da un luogo (roba come int foo(){ return do_foo(); } int do_foo(){ /*actual code*/ } è il peggiore, IMO) Quindi, per capire un effettivo utile funzione composta di questi pezzi, devo inseguire ogni subfunction e) è facile perdersi b) facile perdere di vista possibili ottimizzazioni. Direi che, se ben si inserisce in una schermata e non c’è potenziale per il riutilizzo, non dividere.
  • Il vantaggio principale ho trovato (per i metodi di produzione più piccolo) è che sono più facilmente verificabili, perché il loro ambito di applicazione/responsabilità è più piccolo, e si inserisce “in” una mente umana più facilmente.
  • Si tratta di un equilibrio. Grande monolitico funzioni sono sicuramente un no-no, ma troppi inutili micro-funzioni possono danneggiare la leggibilità troppo, almeno per me che non.
  • Sono assolutamente sentire, e io rispetto che hai diritto alla tua opinione. Mi limiterò a condividere con voi che ho usato per pensare in quel modo un paio di anni fa, ma hanno trasformato in piccolo metodo camp. Non ho trovato di attraversare percorsi di esecuzione nel file. un grep (o equivalente) ottiene il lavoro fatto la maggior parte del tempo. Ho appena trovato i vantaggi di mantenere le cose piccole per essere abbastanza tangibile.
  • Uno dei problemi con lunghi metodo di programmazione è che temps programmatori, soprattutto all’inizio programmatori di scrivere codice modulare. Il codice dovrebbe essere situato nelle classi con i dati funziona, a volte chiamato “oggetto di programmazione”. Questo aiuta a ridurre la duplicazione del codice. Lungo metodo di programmazione tende a creare una cultura in cui l’oggetto di programmazione non è sottolineato.

InformationsquelleAutor Pistos | 2008-10-30

 

12 Replies
  1. 36

    Ho sempre pausa lunga metodi logici pezzi e cercare di fare piccoli metodi di fuori di essi. Io non normalmente girare un paio di righe in un metodo separato fino a quando ne ho bisogno in due luoghi diversi, ma a volte faccio solo per aiutare la leggibilità, o se voglio provarla in isolamento.

    Fowler Refactoring è tutto su questo argomento, e mi raccomando.

    Qui una semplice regola empirica che uso di Refactoring. Se una sezione di codice è un commento che ho potuto ri-parola in nome di un metodo, tirarlo fuori e renderlo un metodo.

    • counldn non essere più d’accordo!! (la tua risposta mi ha salvato una volta)
  2. 13

    La dimensione del metodo è direttamente collegato al suo complessità ciclomatica.

    Principali vantaggi di mantenere la dimensione del metodo di piccole dimensioni (il che significa che la divisione di un grande metodo in diversi metodi di piccole dimensioni) sono:

    • meglio i test di unità (a causa della bassa complessità ciclomatica)
    • meglio di debug a causa di un più esplicito stack trace (invece di un errore all’interno di un gigante metodo)
    • Concordato. In altre parole, la profondità di annidamento di blocchi rende il codice difficile da capire. Un modo per ridurre la profondità di annidamento di blocchi è quello di rompere un metodo in più piccoli metodi. Ci sono altri modi, quali primi e più ritorna.
  3. 9

    Come sempre non si può dire: dipende. È più una questione di denominazione e definizione dell’attività di un metodo. Ogni metodo deve fare un (non di più) ben definito compito e dovrebbe fare completamente. Il nome del metodo deve indicare l’attività. Se il tuo metodo è denominato DoAandB() potrebbe essere meglio avere diversi metodi di DoA() e DoB(). Se avete bisogno di metodi come setupTask, executeTask, FinishTask, può essere utile combinare.

    Alcuni punti che indicano che un’unione di diversi metodi possono essere utili:

    • Un metodo non può essere utilizzato da solo, senza l’utilizzo di altri metodi.
    • Devi stare attento a chiamare alcuni dipendenti metodi nel giusto ordine.

    Alcuni punti che indicano che una rottura del metodo potrebbe essere utile:

    • Alcune linee esistenti metodo chiaro indipendente compito.
    • Unit-testing di grande metodo diventa problematico. Se gli esami sono più facili da scrivere per metodi indipendenti, quindi dividere il metodo big up.

    Come spiegazione per l’unità-prova-argomento: ho scritto un metodo, che ha fatto alcune cose tra cui IO. IO-era molto difficile prova, così ho pensato su di esso. Sono giunto alla conclusione, che il mio metodo ha fatto 5 logico e indipendente passi, e solo uno di essi ha coinvolto l’IO. Così ho diviso il mio metodo in 5 piccoli, quattro di loro erano di facile test.

  4. 6

    Metodi di piccole dimensioni ogni volta.

    Sono auto di documentazione (er, se nominato)

    Abbattere il problema in parti gestibili – si sono KeepingItSimple.

    È possibile utilizzare tecniche OO più facilmente (e ovviamente) spina nel comportamento. Il grande metodo è, per definizione, procedurali e quindi meno flessibile.

    Sono unità testabili. Questo è il killer, semplicemente non si può unit test enormi metodo che esegue un carico di compiti

    • +1 per la semplicità e la facilità di prova. Aggiungere riutilizzabili e hai un lavoro. 🙂
  5. 3

    Qualcosa ho imparato dal Codice libro Completo:

    • Metodi di scrittura/funzioni in modo che
      implementare un blocco(o unità o attività)
      di logica. Se che richiede ripartizione
      in sotto attività, quindi scrivere un
      separata, un metodo/funzione per loro
      e li chiamano.
    • Se trovo che il metodo/funzione
      il nome è sempre tempo poi cerco di
      esaminare il metodo per vedere che si può
      essere suddivisi in due metodi.

    Spero che questo aiuta

  6. 2

    Faccio ogni funzione di fare una cosa e una cosa soltanto, e cerco di non nido troppi livelli di logica. Una volta che si inizia a rompere il vostro codice in di nome funzioni, diventa molto più facile da leggere, e praticamente auto-documentante.

  7. 2

    Trovo che avere molti metodi di piccole dimensioni rende il codice più facile da leggere, gestire ed eseguire il debug.

    Quando sto leggendo un unità che implementa la logica di business, posso seguire meglio il flusso se vedo una serie di chiamate di metodo che descrive il processo. Se mi interessa come il metodo è implementato, posso andare a cercare nel codice.

    Sembra più un lavoro ma, in definitiva, consente di risparmiare tempo.

    C’è un arte, credo, per sapere cosa incapsulare. Ognuno di noi ha qualche lieve differenza di opinione. Se potessi mettere in parole direi che ogni metodo deve fare una cosa che può essere descritto come un compito completo.

  8. 1

    Alcune regole di base:

    • Funzioni non deve essere più lungo di quello che può essere visualizzato sullo schermo
    • Rompere le funzioni in quelle più piccole se si rende il codice più leggibile.
    • Il tuo primo commento non avrebbe funzionato nella maggior parte dei casi, ma io sono un 30 pollici di schermo. Inoltre, ho visto un collega con il suo monitor girato in verticale. Quindi penso che una nuova regola del pollice è necessario.
  9. 1

    Il più grande è il metodo, il più difficile da testare e mantenere. Trovo che la sua molto più facile per capire come un grande processo funziona quando il suo suddiviso in atomic passi. Inoltre, questo è un primo grande passo per rendere il vostro classi estensibile. È possibile contrassegnare i singoli passaggi virtuale (per eredità), o spostarli in altri oggetti (composizione), rendendo il comportamento dell’applicazione più facile da personalizzare.

  10. 1

    Io di solito andare per la suddivisione di funzioni in piccole funzioni che consentono di eseguire una singola, atomic compito, ma solo se tale funzione è complessa, basta garantiscano esso.

    In questo modo, io non finiscono con più funzioni per il semplice compiti e le funzioni che faccio estrarre in genere può essere utilizzato altrove in quanto non tentare di ottenere troppo. Questo aiuta anche i test di unità, come ogni funzione (come logico, atomic azione) possono poi essere analizzati singolarmente.

  11. 0

    Personalmente, mi chino in modo significativo in direzione di preferire di più, piccoli metodi, ma non al punto di religioso che mira ad un massimo di conteggio. Il mio criterio primario obiettivo è quello di mantenere il mio codice SECCO. Il minuto ho un blocco di codice che viene duplicato (in spirito o, addirittura, da testo), anche se potrebbe essere 2 o 4 righe, mi SECCA che il codice in un metodo separato. A volte mi capita di farlo in anticipo se penso che c’è una buona probabilità che sarà riproposta in futuro.

    Il rovescio della medaglia, ho sentito anche sostenuto che, se la vostra rottura metodo è troppo piccolo, nel contesto di un team di sviluppatori, un compagno di squadra non è probabile che per conoscere il tuo metodo, e di scrivere sia in linea o scrivere il suo proprio piccolo metodo che fa la stessa cosa. Questo è certamente una brutta situazione.

    Alcuni anche provare a sostenere che non è più leggibile per mantenere le cose in linea, un lettore in grado di leggere solo top-down, invece di dover saltare le definizioni di metodo, possibilmente su più file. Personalmente, credo che l’esistenza di una traccia dello stack rende questo non è molto di un problema.

  12. 0

    Dipende un po ‘ … sulla mentalità. Ancora, questo non è un supponente domanda.

    La risposta invece in realtà dipende dal contesto linguistico.

    In Java/C#/C++ mondo, dove le persone sono di seguito il “Codice Pulito” scuola, come predicato da Robert Martin, quindi: molti metodi di piccole dimensioni sono la strada da percorrere.

    Un metodo ha un nome e non una cosa. Un livello di nidificazione, che è. Che limiti la sua lunghezza per 3, 5, max 10 righe.

    E onestamente: trovo che questo modo di codifica assolutamente superiore a qualsiasi altro “stile”.

    L’unico svantaggio di questo approccio è che si finisce con molti metodi di piccole dimensioni, in modo da ordinare all’interno di un file/classe può diventare un problema. Ma la risposta a questo è quello di utilizzare un IDE decente che permette di navigare facilmente avanti e indietro.

    Così, l’unica “legit” motivo per usare l’ “tutta roba che va in un metodo/funzione” è quando il tuo team funziona così, e preferisce che stile. O quando non è possibile utilizzare decente utensili (ma poi la navigazione che grande e brutto funzione non funziona).

Lascia un commento