Цикломатическая сложность в Swift

Сегодня мы поговорим о том, что такое цикломатическая сложность и как с ней работать в Swift.

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

Цикломатическая сложность — это модный термин, обозначающий количество точек принятия решений в коде. На самом деле это очень просто. По сути, чем больше у вас точек принятия решений — например, операторов if, switch, циклов и так далее, — тем сложнее становится ваш код. А чем сложнее код, тем труднее его понимать, тестировать и поддерживать.

Разработчику Swift важно знать о цикломатической сложности и о том, как она влияет на качество и сопровождаемость вашего кода. Высокий уровень цикломатической сложности может затруднить отладку и оптимизацию вашего приложения и привести к повышенному риску ошибок и недочетов.

Но не волнуйтесь, есть стратегии, которые вы можете использовать для снижения цикломатической сложности и улучшения качества вашего Swift-кода. Разбивая сложные функции на более мелкие модульные части и используя операторы потока управления, такие как guard и if let, для упрощения точек принятия решений, вы можете сделать свой код более эффективным и простым в сопровождении.

В этой статье мы подробно рассмотрим, что такое цикломатическая сложность, почему она важна для разработчиков и стратегии ее уменьшения в вашем коде. К концу этой статьи вы будете вооружены знаниями и инструментами, необходимыми для написания более чистого и удобного для сопровождения кода на Swift, что сделает вашу жизнь как разработчика проще и приятнее.

Давайте писать!

Что такое цикломатическая сложность

Цикломатическая сложность — это количественный показатель числа линейно независимых путей в исходном коде программы. Он измеряет количество точек принятия решений или ответвлений в программе и сложность логики, используемой для навигации по этим ответвлениям.

Чем выше цикломатическая сложность, тем сложнее поток управления в приложении. Когда мы разрабатываем программное обеспечение, мы всегда стремимся к наименьшей сложности, чтобы обеспечить хорошую сопровождаемость кода.

Почему цикломатическая сложность важна

Высокая цикломатическая сложность может сделать код более трудным для чтения, понимания и сопровождения. Это может привести к тому, что код будет сложнее тестировать, отлаживать и модифицировать. Высокая сложность может увеличить вероятность ошибок в коде, исправление которых может быть дорогостоящим.

Снижая цикломатическую сложность программы, разработчики могут облегчить понимание, сопровождение и тестирование кода, что в конечном итоге приведет к уменьшению количества ошибок и повышению эффективности разработки.

Измерение цикломатической сложности в Swift

Цикломатическую сложность можно измерить с помощью формулы, основанной на количестве точек принятия решений и количестве линейно независимых путей в коде. В Swift для измерения цикломатической сложности разработчики могут использовать такие инструменты, как встроенный статический анализатор Xcode или инструменты сторонних разработчиков, например SwiftLint.

Статический анализатор Xcode обеспечивает визуализацию потока управления программы, выделяя точки принятия решений и циклы. Он также предоставляет значение цикломатической сложности для каждого метода или функции.

SwiftLint — популярный сторонний инструмент, который включает в себя правило ограничения цикломатической сложности, которое может быть настроено в соответствии со стандартами разработки в комапнии.

Пример

Посмотрите приведенный ниже код:

func calculateGrade(score: Int) -> String {
    switch score { // first branch
    case 90...100:
        return "A"
    case 80..<90:
        return "B"
    case 70..<80:
        return "C"
    case 60..<70:
        return "D"
    default:
        if score < 60 { // second nested branch
            return "F"
        } else {
            if score > 100 { // third nested branch
                return "Invalid score"
            } else {
                return "Unknown error"
            }
        }
    }
}

Эта функция принимает на вход числовой балл и возвращает буквенную оценку на основе шкалы оценок. Однако она имеет высокую цикломатическую сложность из-за множества точек принятия решений в коде.

В частности, в функции есть два оператора switch и вложенные операторы if внутри дефолтного switch. Эти точки принятия решений увеличивают цикломатическую сложность функции и делают ее более сложной для понимания, тестирования и сопровождения.

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

Давайте решим эту проблему прямо сейчас!

Уменьшение цикломатической сложности

Чтобы уменьшить цикломатическую сложность в Swift, разработчики могут использовать несколько приемов. Один из распространенных методов — упрощение потока управления путем использования защитных операторов вместо вложенных операторов if. Это может сделать код более читабельным и сократить количество ветвлений в коде.

Другая техника заключается в рефакторизации сложных методов или функций на более мелкие, более управляемые части. Это позволяет разбить сложный код на более мелкие и понятные фрагменты, которые легче тестировать и поддерживать.

Решение проблемы

Для решения приведенного выше примера нам нужно просто извлечь логику и поместить ее в оператор guard.

Посмотрите на решение ниже:

func calculateGrade(score: Int) -> String {
    guard score >= 0 && score <= 100 else { // one branch
        return "Invalid score"
    }
    
    switch score { // one branch
    case 90...100:
        return "A"
    case 80..<90:
        return "B"
    case 70..<80:
        return "C"
    case 60..<70:
        return "D"
    default: // the last if was just one more case
        return "F"
    }
}

Это решение интересно тем, что теперь у нас больше нет вложенных ветвей/точек, и наш код действительно легко понимать. А это, друзья мои, и есть цель устранения цикломатической сложности вашего кода.

Заключение

Цикломатическая сложность — это важный аспект качества кода, который может повлиять на читаемость, сопровождаемость и тестируемость программы. Понимая и измеряя цикломатическую сложность в коде, разработчики могут повысить качество и эффективность своей работы.

Я надеюсь, что отныне вы будете дважды думать увеличивая количество вложенных ветвей/if в своем приложении, ваше будущее будет вам благодарно!

Источник