Riduzione di complessità ciclomatica

Question

Ho un blocco di codice che sto avendo un problema che riduce la complessità ciclomatica di. A causa delle molteplici condizioni che devono corrispondere, non sono sicuro che il modo migliore per abbatterlo ulteriormente. A complicare le cose è che in 2 casi viene creato un nuovo oggetto, ma non nel terzo (richiama un altro metodo). Questo è il pseudocodice:

if (!cond3 && !cond1 && cond2 && cond4) { 
     // actions to perform 
     calculateValues(); 
     return result; 
    } else if (!cond1 && cond2 && cond3) { 
     // actions to perform 
     Object result = new Result(); 
     return result; 
    } else if (!cond4 && cond3 && cond1 && cond5) { 
     // actions to perform 
     Object result = new Result(); 
     return result; 
    } else { 
     // throw error because inputs are invalid 
    } 

Answer 1

Si dovrebbe refactoring che il codice, utilizzando metodi di astrarre queste condizioni, alta cyclomatic indica che i codici hanno bisogno di refactoring. Ad esempio, supponiamo che: !cond4 && cond3 && cond1 && cond5 test se l'utente loggato ha una macchina, allora si dovrebbe refactoring quella combinazione di condizioni a un metodo:

private boolean loggedUsedHasCar() { 
    return !cond4 && cond3 && cond1 && cond5; 
} 

fare la stessa cosa per le altre condizioni. Le dichiarazioni if con 4 condizioni sono probabilmente molto difficili da leggere. Estrazione tali dichiarazioni ridurrà il vostro metodo di complessità ciclomatica e rendere il codice più leggibile

Answer 2

È possibile diminuire la complessità cyclometric a 11 con l'estrazione parte comune delle vostre equazioni come nuova variabile

boolean common = !cond1 && cond2; 
... 
if (!cond3 && common && cond4) { 
    // actions to perform 
    calculateValues(); 
    return result; 
} else if (common && cond3) { 
    // actions to perform 
    Object result = new Result(); 
    return result; 
} else if (!cond4 && cond3 && cond1 && cond5) { 
    // actions to perform 
    Object result = new Result(); 
    return result; 
} else { 
    // throw error because inputs are invalid 
}  

Answer 3

Sono molto interessato al vostro problema e provato in precedenza proposto una soluzione con l'estrazione di condizioni ai metodi separati come questo

public class Test { 

public static void main(String[] args) { 
    cyclometricComplexityTest(); 
} 

static boolean cond1 = true; 
static boolean cond2 = true; 
static boolean cond3 = true; 
static boolean cond4 = true; 
static boolean cond5 = true; 

public static Object cyclometricComplexityTest() { 
    if (isBoolean1()) { 
     // actions to perform 
     Object result = null; 
     calculateValues(); 
     return result; 
    } else if (isBoolean2()) { 
     // actions to perform 
     Object result = new Result(); 
     return result; 
    } else if (isBoolean3()) { 
     // actions to perform 
     Object result = new Result(); 
     return result; 
    } else { 
     throw new RuntimeException(); 
    } 
} 

static boolean isBoolean1() { 
    return !cond3 && !cond1 && cond2 && cond4; 
} 

private static boolean isBoolean2() { 
    return !cond1 && cond2 && cond3; 
} 

private static boolean isBoolean3() { 
    return !cond4 && cond3 && cond1 && cond5; 
} 

static void calculateValues() {} 

static class Result {} 
} 

I risultati di riduzione della complessità ciclometrica sono qui (ho usato MetricsReloaded IntelliJ IDEA plugin). Funziona davvero diffondendo la complessità tra principali ed ausiliarie metodi :)

P.S. cosa interessante: ho provato ad estrarre le tue condizioni come variabili locali e non ho ridotto la complessità del metodo come inizialmente mi aspettavo.