Kotlin - Вложенные функции против частной функции с 1 callite

Question

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

class Foo {
    fun bar() : Int {
        fun a() : Int {
            // Do a load of stuff
            return 1
        }
        fun b() : Int {
            // Do a load of stuff
            return 1
        }

        return a() + b()
    }
}

Я делаю это, поскольку он обеспечивает инкапсуляцию этих функций, которые пока имеют только один callite;

Однако на работе меня часто просят преобразовать эти функции в частные функции включающего класса, например:

class Foo {
    fun bar() : Int {
        return a() + b()
    }

    private fun a() : Int {
        // Do a load of stuff
        return 1
    }

    private fun b() : Int {
        // Do a load of stuff
        return 1
    }
}

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

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

Я всегда подчиняюсь и перемещаю их в частные функции класса после того, как мой аргумент не преследует рецензента (ов). неверно?

Answer 1

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

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

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