Явная типизация в Groovy: иногда или никогда?
[Позже: Все еще не может выяснить, имеет ли Groovy статический контроль типов (кажется, что он не делает), или если байт-код, сгенерированный использующий явную типизацию, отличается (кажется, что это). Так или иначе, по вопросу]
Одни из основных отличий между Groovy и другими динамическими языками - или по крайней мере Ruby - то, что можно статически явно ввести переменные, когда Вы хотите.
Тем не менее, когда необходимо использовать статический контроль типов в Groovy? Вот некоторые возможные ответы, о которых я могу думать:
- Только, когда существует проблема производительности. Переменные со статическим контролем типов быстрее в Groovy. (или они? некоторые вопросы об этой ссылке)
- На открытых интерфейсах (методы, поля) для классов, таким образом, Вы получаете автоматическое заполнение. Эта возможная/верная/полностью несправедливость?
- Никогда, это просто загромождает код и побеждает цель использовать Groovy.
- Да, когда Ваши классы будут наследованы или использоваться
Я только не интересуюсь тем, что ВЫ делаете, но что еще более важно что Вы видели вокруг в проектах, кодированных в Groovy. Какова норма?
Примечание: Если этот вопрос является так или иначе неправильным или пропускает некоторые категории статически-динамических, сообщите мне, и я зафиксирую его.
4 ответа
В моем стаж, нормы нет. Некоторые используют типы много, некоторые никогда их не используют. Лично я всегда стараюсь использовать типы в сигнатурах моих методов (для параметров и возвращаемых значений). Например, я всегда пишу такой метод
Boolean doLogin(User user) {
// implementation omitted
}
Хотя я мог бы написать его так
def doLogin(user) {
// implementation omitted
}
, я делаю это по следующим причинам:
- Документация : другие разработчики (и я) знают, какие типы будут предоставлены и возвращается методом без чтения реализации
- Type Safety : хотя в Groovy нет проверки во время компиляции, если я вызываю статически типизированную версию
doLoginс параметром, отличным от пользователя он немедленно выйдет из строя, поэтому проблему, скорее всего, будет легко исправить. Если я вызываю динамически типизированную версию, она завершится ошибкой через некоторое время после вызова метода, и причина сбоя может быть не сразу очевидна. - Завершение кода : это особенно полезно при использовании хорошей IDE (например, IntelliJ), поскольку оно может даже обеспечить завершение для динамически добавляемых методов, таких как динамические средства поиска класса домена.
Я также довольно часто использую типы внутри реализация моих методов по тем же причинам.Фактически, я не использую типы только в следующих случаях:
- Я действительно хочу поддерживать широкий диапазон типов. Например, метод, преобразующий строку в число, может также преобразовать коллекцию или массив строк в числа
- Лень! Если область видимости переменной очень короткая, я уже знаю, какие методы я хочу вызвать, и у меня еще нет импортированного класса, тогда объявление типа кажется большим трудом, чем оно того стоит.
Кстати, я бы не стал слишком сильно доверять тому сообщению в блоге, которое вы связали с утверждением, что типизированный Groovy намного быстрее, чем нетипизированный Groovy. Я никогда не слышал об этом раньше, и я не нашел доказательства очень убедительными.
Groovy не поддерживает статическую типизацию. Убедитесь в этом сами:
public Foo func(Bar bar) {
return bar
}
println("no static typing")
Сохраните, скомпилируйте этот файл и запустите его.
Я видел информацию о типах, используемую в основном в служебных классах для общедоступных методов. В зависимости от того, насколько сложен список параметров, даже здесь я обычно вижу только набранный тип возвращаемого значения. Например:
class WorkflowService {
....
WorkItem getWorkItem(processNbr) throws WorkflowException {
...
...
}
}
Я думаю, что это полезно, потому что оно явно сообщает пользователю службы, с каким типом он будет иметь дело, и действительно помогает с помощью кода в IDE.
Я работал над несколькими проектами Groovy, и мы придерживались таких соглашений:
Все типы в общедоступных методах должны быть указаны.
public int getAgeOfUser (String userName) { ... }
- Все частные переменные объявляются с использованием ключевого слова def .
Эти условности позволяют добиться многого.
Прежде всего, если вы используете совместную компиляцию, ваш Java-код сможет легко взаимодействовать с вашим Groovy-кодом.Во-вторых, такие явные объявления делают код в больших проектах более читабельным и устойчивым. И, конечно же, автозаполнение - тоже важное преимущество.
С другой стороны, область действия метода обычно довольно мала, и вам не нужно явно объявлять типы. Кстати, современные IDE могут автоматически заполнять ваши локальные переменные, даже если вы используете defs.