Цикломатическая сложность в фрагменте кода с несколькими точками выхода

Думаю, хитрость в том, что подсчитываются логические операторы.

На основе вашей ссылки Metrics (http://metrics.sourceforge.net/) в разделе McCabe Cyclomatic Complexity :

1 Начальный поток

3 точки принятия решения (если, за, если)

3 условных логических оператора (||, ||, ||)

всего: 7

Я думаю, что главное здесь то, что условные выражения замыкаются, что является формой потока управления. Что помогает, так это переписать код, чтобы сделать это явным. Такая нормализация является обычным явлением при анализе программ. Некоторая специальная нормализация (не формальная, и машина не сгенерирует это, но она передает суть) заставит ваш код выглядеть следующим образом:

public static boolean validatePassword(String password) {
    int len = password.length();

    //evaluate 'len < 8 || len > 20'
    bool cond1 = len < 8;
    if (!cond1) cond1 = len > 20;
    //do the if test
    if (cond1)
        return false;

    boolean hasLetters = false;
    boolean hasDigits = false;
    //for loops are equivalent to while loops
    int i = 0;
    while(i < len) {
        if (!Character.isLetterOrDigit(password.charAt(i)))
            return false;

        //evaluate 'hasDigits || Character.isDigit(password.charAt(i))'
        bool hasDigitsVal = hasDigits;
        if (!hasDigitsVal) hasDigitsVal = Character.isDigit(password.charAt(i));
        //hasDigits = ...
        hasDigits = hasDigitsVal

        //evaluate 'hasLetters || Character.isLetter(password.charAt(i))'
        bool hasLettersVal = hasLetters;
        if (!hasLettersVal) hasLettersVal = Character.isLetter(password.charAt(i));
        //hasLetters = ...
        hasLetters = hasLettersVal;

        i++;
    }

    //evaluate 'hasDigits && hasLetters'
    bool cond2 = hasDigits;
    if (cond2) cond2 = hasLetters;
    //return ...
    return cond2;
}

Обратите внимание, что операторы || и && по сути просто добавляют в код операторы if. Также обратите внимание, что теперь у вас есть 6 операторов if и один цикл while! Может быть, это та семерка, которую вы искали?

Насчет нескольких точек выхода - это отвлекающий маневр. Считайте, что каждая функция имеет один выходной узел, конец функции. Если у вас есть несколько операторов return, каждый оператор return будет рисовать край этого выходного узла.

void foo() {
    if (cond1) return a;
    if (cond2) return b;
    return c;
}

График будет выглядеть так, где -----val----> EXIT означает выход из функции со значением val:

START -> cond1 ------------------------a------------> EXIT
           |                                            |
         cond2 ------------------------b----------------+
           |                                            |
         return -----------------------c----------------|

Если вы переписываете код, вы просто добавляете еще один узел "pre-return", который затем переходит к узлу выхода:

void foo() {
    int val;
    if (cond1) {
        val= a;
    }
    else {
        if (cond2) {
            val= b;
        }
        else {
            val= c;
        }
    }
    return val;
}

Теперь это выглядит так:

START -> cond1 ---> val=a --------------------------> return ----val----> EXIT
           |                                            |
         cond2 ---> val=b ------------------------------+
           |                                            |
           + -----> val=c ------------------------------+

Он по-прежнему сложен, а код просто уродливее.

Как красиво объяснено здесь:

Цикломатическая сложность = (2 + ifs + loop + case - return), где:

* ifs is the number of IF operators in the function,
* loops is the number of loops in the function,
* cases is the number of switch branches in the function (without default), and
* return is the number of return operators in the function.

Как уже было сказано, вычисляются и логические условия.

Например, if (len < 8 || len > 20) считается за 3 условия:

1. if
2. len<8
3. len > 20

Это означает, что ваш код имеет сложность 2 + 8 - 3 = 7, где:

• 2 - он всегда там (см. Формулу наверху)
• 8 - количество веток
• 3 - количество возвратов