Стоит ли использовать префиксы типа и области действия в соглашениях об именах?

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

int nTickCount  
bool bConnected  
object[] m_aItems  
fSum += fWeight * fValue  
class cManager  
enum etSystemStates  
etSystemStates eState   
cManager.cs

Но стоит ли это на самом деле? Мне трудно судить о суммарном влиянии, которое такое соглашение об именах оказывает на понимание и обнаружение ошибок, но визуально это выглядит некрасиво. Кроме того, каждый класс и файл в проекте, называемый cSomething, кажется довольно глупым.

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

Что вы считаете самым элегантным и эффективным соглашением об именах, если оно вообще нужно использовать? Обозначает ли он тип и / или объем?

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

Префиксы, такие как tbl для таблицы базы данных, int для целого числа и т. Д., Как правило, бесполезны - в таких случаях легко понять, что есть что из контекста или из ваших инструментов разработки. Что-то вроде imp для имперских измерений и met для метрики имеет гораздо больший смысл, потому что в противном случае вы можете видеть только то, что они являются числами с плавающей запятой.

area = width * height

выглядит отлично в то время как

impArea = metWidth * impHeight

сразу показывает, что что-то не так.

Лично я просто использую описательные имена переменных. $ number_of_items, очевидно, является целым числом. $ input_file_handle, $ is_active и $ encrypted_password имеют очевидные типы как с точки зрения типа данных языка, так и семантического типа.

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

Статья Википедии содержит раздел о ее плюсах и минусах.

Да, префиксы могут быть полезны, но у меня есть пара предложений:

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

В строго статически типизированных языках не просто копируйте тип переменной. Например, «bSubscribeed» - это недопустимое имя для логической переменной в C # или Java, потому что ваша IDE уже знает, какой это тип. С другой стороны, в C, в котором отсутствует логический тип, это будет полезной информацией.

В C # и Java вы можете рассмотреть префикс, чтобы показать, что объект может быть нулевым. Или, что строка была html-экранированной. Или то, что оно представляет регулярное выражение или оператор SQL. Или что массив был отсортирован. Использовать ваше воображение.

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

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

Что более важно для FAR: используйте описательные имена для переменных и функций. В вашем примере с «sum», «weight» и «value» вы можете дать более значимые имена: «totalCost», «lumberWeight», «lumberValuePerOunce» (я делаю некоторые предположения здесь)

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

Большинство разработчиков .NET следуют рекомендациям Microsoft по проектированию ( http://msdn.microsoft.com/en-us/library/ms229042.aspx ), которые очень похожи на Java (главное отличие заключается в том, что Microsoft предпочитает Pascal Case для имен членов, тогда как Java благоволит к верблюжьему делу).

Кроме того, я бы сказал, что ваш пример кода гораздо менее читабелен из-за добавленного вами дополнительного шума.

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

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

Прежде всего, действительно ли intStudentCount понятнее, чем, например, numberOfStudents? Не было бы "invoiceLineItems", по крайней мере, столь же информативным, как "aobjItems". (Тип данных должен соответствовать значению данных в проблемной области, а не представлению низкого уровня.)

Что касается второго пункта, что происходит, когда, например, преждевременный выбор типа int заменяется на long или double? Что еще хуже, что происходит, когда конкретный класс преобразуется в интерфейс с несколькими реализующими классами? Любая практика, которая увеличивает бремя реалистичных сценариев обслуживания, кажется мне сомнительной.

Это также может зависеть от того, почему вы используете префикс имени, а не от того, с каким префиксом вы его используете.

В качестве примера я обычно использую 1-2-буквенный префикс для имен элементов управления в форме. Не потому, что я не знаю, что компилятор легко найдет правильный класс для кнопки (в качестве примера), но я склонен сначала проектировать большие формы, а потом писать большую часть кода.

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

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

На мой взгляд, это зависит от языка и размера проекта. На самом деле я никогда не заходил так далеко, чтобы использовать префиксы типов во всех моих переменных, но вы действительно хотите назвать их четко.

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

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

Тем не менее, в основном я не думаю, что это стоит, особенно для типов значений.

Например, предположим, что вы имели:

short shortValue = 0;
//stuff happens

Месяцы спустя вы обнаружите, что вам нужно это изменить - короткая позиция недостаточно велика. Теперь у вас есть:

int shortValue = 0;
//stuff happens

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

Вам лучше иметь имя, которое описывает то, что оно содержит:

int loopCounter = 0;
//stuff happens

Если позже это должно измениться на длинный: нет проблем.

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

Я всегда был склонен использовать сокращение от 2 до 4 символов для типа перед самой переменной. Иногда это кажется утомительным, но когда вы работаете со сложными типами данных или ситуациями, это становится полезным. Я думаю, что это попадает в категорию нижних верблюжьих.

Глядя на ваш пример выше, он будет слегка переоборудован, чтобы быть:

int intTickCount;
bool boolConnected;
object[] aobjItems;

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

taStore.Fill(dtStore);

... что указывает на то, что мой Store TableAdapter заполняется в Store DataTable.

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

Чем менее загадочно, тем лучше ...

Почему есть такой метод:

public boolean connect( String h, int p );

Когда у вас может быть что-то вроде этого:

public boolean connect( String hostName, int port );

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