Анонимные функции считаются вредными?

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

Я думаю, мы все можем согласиться на следующие факты:

человеческий разум не имеет дело с более чем 7 плюс минус две сущности (Закон Миллера)
глубокий отступ считается плохая практика программирования и обычно указывает на проблемы с дизайном, если вы отступали более чем на три или четыре уровня. Это распространяется на вложенные объекты, и это хорошо представлено в записи Zen python "Плоский лучше, чем вложенный".
Идея иметь имя функции как для справки, так и для облегчения документирования выполняемой задачи. Мы знаем или можем ожидать, что делает функция removeListEntry(). Самодокументирующийся, понятный код важен для отладки и удобочитаемости.

В то время как анонимные функции являются очень приятной функцией, ее использование приводит к глубоко вложенному дизайну кода. Код быстро записывается, но его трудно читать. Вместо того, чтобы вынуждать изобретать именованный контекст для функциональности и сглаживать иерархию вызываемых объектов, он поощряет "углубляться на один уровень", подталкивая ваш мозговой стек и быстро переполняя правило 7 +/- 2. Подобная концепция выражена в Алане Купере " О Face", цитируя свободно "люди не понимают иерархии". Как программисты мы понимаем иерархии, но наша биология все еще ограничивает наше понимание глубокого гнездования.

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

CW, поскольку нет правильного ответа.

Ответ 1

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

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

Ответ 2

Анонимные функции более полезны функционально, чем вредоносны. Я думаю, что если вы правильно отформатируете свой код, у вас не должно быть проблем. У меня нет проблем с этим, и я уверен, что не могу обрабатывать 7 элементов, не говоря уже о 7 + 2:)

Ответ 3

На самом деле иерархии помогают преодолеть правило 7 +/- 2 так же, как и ООП. Когда вы пишете или читаете класс, вы читаете его содержимое и ничего из внешнего кода, поэтому имеете дело с относительно небольшой частью объектов. Когда вы смотрите на иерархии классов, вы не заглядываете внутрь них, а значит, снова вы имеете дело с небольшим количеством объектов.

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

Закрытия (или анонимные функции) просто помогают разбить код немного по-другому, чем OOP, но на самом деле они не создают никаких иерархий. Они здесь, чтобы помочь вам выполнить ваш код в контексте другого блока кода. В С++ или Java вы должны создать для этого класс, в JavaScript функция достаточно. Разумеется, автономный класс легче понять, поскольку человеку просто проще смотреть на него как на автономный блок. Функция, кажется, намного меньше по размеру, и мозг иногда думает, что она может понять ее и код вокруг нее в то же время, что обычно плохое. Но вы можете тренировать свой мозг, чтобы не делать этого:)

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

Ответ 4

Смешно, JavaScript позволит вам назвать "анонимные" функции:

function f(x) {
   return function add(y) {
        return x+y;
   };
}

Ответ 5

Я думаю, что закрытие имеет огромные преимущества, которые нельзя игнорировать. Например, Apple использует "блоки" (закрытие для C) с помощью GCD, чтобы обеспечить очень легкое многопоточность - вам не нужно настраивать контекстные структуры и просто ссылаться на переменные по имени, поскольку они находятся в области видимости.

Я думаю, что большая проблема с Javascript заключается в том, что он не имеет области блока (блоки в этом случае ссылаются на код в фигурных скобках, например, оператор if). Это может привести к огромным осложнениям, заставив программистов использовать ненужные блокировки, чтобы обойти это ограничение дизайна Javascript.

Ответ 6

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

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

Что касается java- script, я считаю, что функциональные переменные выглядят довольно уродливыми и делают код загроможденным (строка encapsulated function (...) {} делает код java- script часто менее читабельным). В качестве примера я предпочитаю синтаксис закрытия groovy ('{}' и '- > ' chars).

Ответ 7

Если функция не понятна без имени, имя, вероятно, слишком длинное. Используйте комментарии для объяснения загадочного кода, не полагайтесь на имена.

Ответ 8

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

На самом деле, чтобы противостоять вашему собственному аргументу, я бы зашел так далеко, чтобы считать функции, связанные с (глобальными) именами, вредными! Проверьте статью Crockford о частных и общественных участниках и узнайте больше.