Come rifattorizzare il codice con istruzioni if sparse ovunque nel codice?

Question

Come rifattorizzare il codice con istruzioni if sparse ovunque nel codice?

#1 da (2 voti)
#2 da (1 voti)

-1

Ho un problema serio con l'applicazione su cui sto lavorando. Ha un sacco di codice procedurale e ora ha bisogno di refactoring ora .. Il problema: abbiamo due diverse applicazioni in generale, ma usano lo stesso "modulo", le funzioni concrete di questo modulo. Assomiglia a questo: (pseudocodice)

// general application
class App1 {
    DoSomething();
}

class App2 {
    DoSomething();
}

// "module":
a;
b;
c;

function DoSomething {
  if (App1) {
    // working with a, b here
  }

  if (App2) {
    // working with a, c here
  }
}

Notare che la funzione "DoSomething" ottiene "a", "b", "c" dall'esterno. Inoltre, questo "DoSomething" può chiamare un'altra funzione al suo interno, "DoSomething 2" ad esempio ..

Questa frase if aka "se App1 allora, altrimenti se App2 allora .." è sparpagliata da tutto il codice, e diventa il problema. Inoltre, il conteggio di questa Applicazione potrebbe aumentare in futuro (

Quale modo migliore per risolvere questo problema? Per favore, puoi dare un consiglio, quali schemi / approcci possono aiutarti qui?

Aggiorna

Questo è un esempio reale del codice, ma tutti i nomi sono stati sostituiti con nomi falsi:

situazione uno - "helpers.js"

import { isApp1 } from '../../..';
import { constTypes } from '../../../../someAnotherHelpers';
import { constSybtypes } from '../../someAnotherHelpersTwo';

const App1Constants = {
  [constTypes.a]: { .. },
  [constTypes.b]: {
    [constSybtypes.b.a]: 33,
  },
};

const App2Constants = {
  [constTypes.c]: 22,
};

const getConstants = isApp1()
  ? App1Constants
  : App2Constants;

situazione due - "alcuni reagiscono classe"

import { isApp1 } ...;

class Test {
  const className = isApp1 ? 'object_app1' : 'object_app2';

  render() {
    <div className={className}>
      ...
    </div>
  }
}

situazione tre - "selector.js" (utilizzata ovunque ..)

import { isApp1 } ...;
import { someAnotherSelector } from '.';
import { someAnotherSelector2 } from '../../../anotherSelectors';

export const someSelector = 
  isApp1()
    ? (state) => { 
      return someAnotherSelector(state.someReducer.variant1);
    }
    : (state) => { 
      return someAnotherSelector2(state.someReducer.variant2);
    }
};

design refactoring

posta 0x10 06.08.2018 - 11:19

fonte

2 risposte

Leggi altre domande sui tag design refactoring

Perché non inserire il certificato TLS nelle risposte DNS? Scrivere promesse eleganti in Node.js

score 2 · Answer 1

Questo è un caso classico in cui è necessario utilizzare una qualche forma di genericità (programmazione generica). Quale genere di programmazione generica da selezionare dipende dalla lingua che stai usando e dai dettagli (che hai astratto troppo per essere utile).

Ma in breve, le forme ovvie di generico da usare includono:

ereditarietà / interfaces
macro / modelli

Macro o modelli sono simili e ciò che è disponibile dipende dalla scelta della lingua. l'ereditarietà / interfacce è probabilmente la forma più utile di programmazione generica ed è disponibile nella maggior parte delle lingue.

eredità :

Se il tuo codice è pieno di cose come

  if (typeof object) == A) {
    do this
  }
  else if (typeof object) == B) {
    do that.
  }

questa è un'opportunità classica per l'orientamento agli oggetti (interfaccia / programmazione basata).

Definisci un'interfaccia (dettagli molto specifici della lingua)

interfaccia PutGoodNameHereForWhatSortsOfThingsTheseDo { metodo virtual void (); // NECESSITA DI UN NOME BENE }

ObjectA e ObjectB ereditano (che potrebbe essere App1 e App2 nell'esempio?) e forniscono l'override appropriato di Method ().

Quindi scrivi il tuo codice come:

object->Method(); // losing all the iffs and type checks

templates / macro :

Invece, se nel tuo codice ci sono schemi che si ripetono, ma non hanno una relazione di ereditarietà evidente come sopra, e SE la tua lingua supporta modelli (come java o C ++), puoi provare:

template<typename A, typename B> 
void DoSomething (A a, B b)
{
  if (a == 1) {
    print "hello";
  }
  if (b != a) {
     print "bye";
  }
}
int X;
double Y;
char Z;
DoSomething (X, Y);
DoSomething  (Y, Z);
...

score 1 · Answer 2

1

Sembra un buon candidato per il modello di metodo del modello . A seconda del contesto più ampio, potresti anche considerare il modello di strategia .

Ecco un esempio di come implementare il metodo del modello in javascript .

risposta data 06.08.2018 - 13:39

fonte