При создании классов в coffeescript, есть ли причина не использовать жирную стрелку для методов экземпляра?
===========================================================================================================

При построении классов в coffeescript, всегда ли есть причина**не** использовать жирную стрелку, например, методы?

Редактировать: Хорошо, тогда! Отличный ответ! :)  
Подводя итог, проблемы:  
- занимает больше памяти  
- невозможность патча  
- Напрашивается вопрос, почему он используется для этого метода?  
Конвенция:  
- Будьте явными при связывании функций.  
- Объявлять жирные стрелочные методы в конструкторе.  
- Используйте столько, сколько хотите, только не в объявлениях классов.  

 есть причины не использовать жирные стрелки всегда. На самом деле я бы поспорил в пользуникогда используя жирные методы :)

Методы тонких стрелок и толстых стрелок - концептуально разные вещи. Первые компилируются в ожидаемый JS-код на основе прототипа; методы принадлежат прототипу класса. Методы с жирными стрелками, с другой стороны, связаны с каждым экземпляром в коде конструктора.

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

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

Но самый важный недостаток, на мой взгляд, более субъективен: введение методов жирных стрелок делает код (и язык) излишне непоследовательным и трудным для понимания.

Код становится более противоречивым, потому что перед введением методов жирной стрелки в любое время мы видим`<someProp>: <someVal>` в определении класса мы знаем, что это означает "объявить свойство с именем`<someProp>` со значением`<someVal>` в классе «прототип» (если`<someProp> == 'constructor'`, что является частным случаем), не имеет значения, если`<someVal>` это число или функция, это будет просто свойство в прототипе. С введением жирных стрелок у нас теперь есть еще один ненужный особый случай: если`<someVal>` это функция с жирными стрелками, она будет делать совсем другое, чем с любым другим значением.

И есть еще одно несоответствие: толстые стрелки[связать`this` иначе](https://github.com/jashkenas/coffee-script/issues/2492) когда они используются в определении метода, чем когда-либо еще. Вместо сохранения внешнего`this` (который внутри`class`, `this` связан с конструктором класса)`this` внутри метода с жирными стрелками находится объект, который не существует, когда метод определен (то есть экземпляр класса).

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

Для всего этого я бы порекомендовал никогда не использовать методы жирной стрелки. Предпочитайте привязывать метод к экземпляру, где он будет использоваться, вместо того, где метод объявлен. Например:

Или, если вы действительно хотите привязать метод к каждому экземпляру во время создания, будьте явны по этому поводу:

Я думаю, что во втором определении`class A` это гораздо более четко, что происходит с`foo` метод, чем в первом определении.

Наконец, обратите внимание, что я не спорю с использованием жирной стрелки вообще. Это очень полезная конструкция, и я все время использую ее для обычных функций; я просто предпочитаю избегать его использования внутри`class` определение метода :)

**редактировать**: Еще один случай против использования жирных стрелок: функции-декораторы:



Сложные причины, высказанные @epidemian для избежания жирной стрелки, хороши и хороши, но учтите следующее:

если вас не волнует (сильно или совсем не интересует) «базовый JS-код на основе прототипов», сгенерированный CoffeeScript, поскольку вы можете писать последовательный и безошибочный код CoffeeScript;если вы не планируете писать крошечные крошечные классы для Java, они будут тратить 99% своего времени на вызовы методов друг друга вверх и вниз по дереву наследования и не будут выполнять большую часть работы в этом процессе; иными словами, если вы понимаете, что чувствительные к производительности «внутренние циклы» не подходят для вызова методов;если вы не планируете украшать, исправлять обезьяны или иным образом изменять методы ваших классов во время выполнения;если вы указали использование жирной стрелки в комментарии к заголовку, для будущих разработчиков, работающих над вашим кодом;тогда я бы порекомендовал**всегда используйте жирную стрелку**, как привычка, как для методов, так и для анонимных функций.

Это сделает ваш код CoffeeScript более простым, безопасным и интуитивно понятным, потому что вы будете знать, что**`this` а также`@` всегда обращайтесь к текущему объекту, метод которого вы определяете**Как и в большинстве других языков программирования, независимо от того, кто будет вызывать ваши функции и методы во время выполнения.

Говоря более формально, жирная стрела делает`this` ключевое слово (и его сокращение`@`) полностью лексически ограничен, как и любой другой идентификатор. История языка программирования показывает, что лексическая область видимости является наиболее интуитивным и менее подверженным ошибкам способом определения идентификаторов области. Вот почему это стало стандартным поведением для всех новых языков давно.

Если вы выберете этот путь,**тонкая стрела становится исключением**и полезный в этом. Вы будете использовать его для подготовки тех конкретных обратных вызовов, где вам нужно`this` ссылаться на что-то определенное во время выполнения вызывающей стороной, а не вашим собственным объектом. Это нелогичное значение`this`, но некоторым библиотекам JS необходимо такое поведение в пользовательских функциях. Тонкая стрелка будет служить для выделения этих фрагментов кода. Если я правильно помню, jQuery обычно предоставляет все, что вам нужно в аргументах функции, поэтому вы можете игнорировать ее искусственное`this`, но другие библиотеки не так доброжелательны.

NB. В CoffeeScript 1.6.1 есть ошибка, связанная с методами жирных стрелок, поэтому вам следует избегать этого. Предыдущие и более поздние версии должны быть в порядке.

ПредставлениеПри использовании в качестве обычной (анонимной) функции жирная стрелка не добавляет никаких накладных расходов. В объявлениях метода[это добавляет**крошечный** ОЗУ и загрузка ЦП](http://nesbot.com/2012/1/20/CoffeeScript-why-is-function-binding-not-the-default) (действительно крошечный: несколько наносекунд и несколько байтов оперативной памяти для каждого вызова метода, и последний исчезает в механизмах с оптимизацией хвостового вызова.)

ИМХО ясность языка и безопасность жирной стрелки дают взамен достаточное основание терпеть и даже приветствовать небольшие накладные расходы. Многие другие идиомы CoffeeScript добавляют свои крошечные накладные расходы к сгенерированному коду (для циклов и т. Д.) С целью сделать поведение языка более согласованным и менее подверженным ошибкам. Жирная стрела ничем не отличается.