Подтвердить что ты не робот

Как назвать переменные

  • Какие правила вы используете для обозначения переменных?
  • Где разрешены одиночные буквы?
  • Сколько информации вы указали в названии?
  • как насчет кода?
  • Каковы ваши предпочтительные бессмысленные имена переменных? (после foo и bar)
  • почему они пишут "foo" и "bar" , а не FUBAR
4b9b3361

ОТВЕТЫ

Ответ 1

function startEditing(){
   if (user.canEdit(currentDocument)){
      editorControl.setEditMode(true);
      setButtonDown(btnStartEditing);
   }
 }

Должен читать как повествовательное произведение.

Ответ 2

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

int postalCodeDistanceMiles;
decimal reactorCoreTemperatureKelvin;
decimal altitudeMsl;
int userExperienceWongBakerPainScale

Я не буду нести ответственность за сбой любых посадочных мест на Марсе (или эквивалентный сбой в моих скучных бизнес-приложениях CRUD).

Ответ 3

Ну, все зависит от языка, в котором вы разрабатываете. Поскольку в настоящее время я использую С#, я стараюсь использовать следующее.

camelCase для переменных.

camelCase для параметров.

PascalCase для свойств.

m_PascalCase для переменных-членов.

Где разрешены одиночные буквы? Я, как правило, делаю это для циклов, но чувствую себя немного виноватым, когда я это делаю. Но с foreach и лямбда-выражениями для циклов на самом деле не так уж и распространены.

Сколько информации вы указали в названии? Если код немного сложно понять, напишите комментарий. Не включайте имя переменной в комментарий, т.е. int theTotalAccountValueIsStoredHere не требуется.

Каковы ваши предпочтительные бессмысленные имена переменных? (после foo и bar) i или x. foo и bar - это слишком учебный пример университетской учебной книги для меня.

почему они пишут "foo" и "bar", а не FUBAR? Традиция

Ответ 4

Это все соглашения С#.

Корпус с изменяемым именем

Случай указывает область. Паскаль-переменные являются полями класса-владельца. Переменные с верблюжью являются локальными для текущего метода.

У меня есть только один префикс-символ. Поля для полей свойств класса Pascal и с префиксом подчеркивания:

private int _Foo;
public int Foo { get { return _Foo; } set { _Foo = value; } }

Там есть какое-то соглашение об именах имен С#, которое я видел там - я уверен, что это документ Microsoft, который не использует префикс подчеркивания. Мне это кажется сумасшедшим. Если я посмотрю в своем коде и вижу что-то вроде

_Foo = GetResult();

самое первое, что я задаю себе, это: "У меня есть веская причина не использовать средство доступа к ресурсам для обновления этого поля?" Ответ часто "Да, и вам лучше знать, что это такое, прежде чем вы начнете обезвреживать этот код".

Однобуквенные (и короткие) имена переменных

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

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

XmlWriterSettings xws = new XmlWriterSettings();
xws.Indent = true;
XmlWriter xw = XmlWriter.Create(outputStream, xws);

Что из кода С# 2.0; если бы я написал это сегодня, конечно, мне не нужна переменная nonce:

XmlWriter xw = XmlWriter.Create(
   outputStream, 
   new XmlWriterSettings() { Indent=true; });

Но в коде С# еще много мест, где мне нужно создать объект, который вы собираетесь пропустить в другом месте, а затем выбросить.

Многие разработчики использовали бы такие имена, как xwsTemp. Я считаю, что суффикс Temp является избыточным. Тот факт, что я назвал переменную xws в ее объявлении (и я использую ее только в пределах визуального диапазона этого объявления, что важно) говорит мне, что это временная переменная.

Другое место, где я буду использовать короткие имена переменных, - это метод, который сильно использует один объект. Вот фрагмент производственного кода:

    internal void WriteXml(XmlWriter xw)
    {
        if (!Active)
        {
            return;
        }
        xw.WriteStartElement(Row.Table.TableName);

        xw.WriteAttributeString("ID", Row["ID"].ToString());
        xw.WriteAttributeString("RowState", Row.RowState.ToString());

        for (int i = 0; i < ColumnManagers.Length; i++)
        {
            ColumnManagers[i].Value = Row.ItemArray[i];
            xw.WriteElementString(ColumnManagers[i].ColumnName, ColumnManagers[i].ToXmlString());
        }
        ...

В мире нет способа, чтобы код был легче читать (или безопаснее изменять), если бы я дал XmlWriter более длинное имя.

О, откуда я знаю, что xw не является временной переменной? Потому что я не вижу его объявления. Я использую только временные переменные в пределах 4 или 5 строк их декларации. Если мне понадобится один для большего количества кода, я либо дам это значащее имя, либо реорганизую код, используя его, в метод, который - эй, какое совпадение - берет короткую переменную в качестве аргумента.

Сколько информации вы указали в названии?

Достаточно.

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

Вот почему это не так важно.

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

В этом блоке кода есть только одна переменная:

        RowManager r = (RowManager)sender;

        // if the settings allow adding a new row, add one if the context row
        // is the last sibling, and it is now active.
        if (Settings.AllowAdds && r.IsLastSibling && r.Active)
        {
            r.ParentRowManager.AddNewChildRow(r.RecordTypeRow, false);
        }

Имена свойств почти делают комментарий избыточным. (Почти. Фактически, причина, по которой свойство называется AllowAdds, а не AllowAddingNewRows, что много думал, но это не относится к этой части кода, поэтому есть комментарий.) имя переменной? Кто заботится?

Ответ 5

  • Я использую только одиночные переменные символа для управления контуром или очень короткие функции.
for(int i = 0; i< endPoint; i++) {...}

int max( int a, int b) {
    if (a > b)
       return a;
    return b;
}
  • Объем информации зависит от области действия переменной, тем больше мест она может быть использована, тем больше информации я хочу иметь имя, чтобы отслеживать его назначение.
  • Когда я пишу пример кода, я пытаюсь использовать имена переменных, как в реальном коде (хотя функции могут иметь бесполезные имена, такие как foo или bar).
  • См. Этимология "Foo"

Ответ 6

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

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

Ответ 7

Какие правила вы используете для обозначения своих переменных?

Как правило, поскольку я являюсь разработчиком С#, я следую соглашениям об именах переменных, указанным в IDesign С# Standard по двум причинам

1) Мне это нравится, и его легко читать. 2) По умолчанию используется Code Style Enforcer AddIn для Visual Studio 2005/2008, который я в наши дни широко используются.

Где разрешены одиночные буквы?

Есть несколько мест, где я допускаю однобуквенные переменные. Обычно это простые петлевые индексы, или математические понятия, такие как координаты X, Y, Z. Кроме этого, никогда! (В другом месте я их использовал, я, как правило, был укушен ими при перечитывании кода).

Сколько информации вы указали в названии?

Достаточно знать ТОЧНО, для чего используется переменная. Как говорит Роберт Мартин:

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

Ответ 8

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

Для переменных цикла я удваиваю букву, чтобы легче находить переменную в файле. Например,

for (int ii=0; ii < array.length; ii++)
{
    int element = array[ii];
    printf("%d", element);
}

Ответ 9

Какие правила вы используете для обозначения своих переменных? Я переключался между подчеркиванием между словами (load_vars), верблюжьей оболочкой (loadVars) и пробелами (loadvars). Классы всегда CamelCase, заглавные.

Где разрешены одиночные буквы? Циклы, в основном. Временные вары в метании кода.

Сколько информации вы указали в имени? Достаточно, чтобы напомнить мне, что это такое, пока я кодирую. (Да, это может привести к проблемам позже!)

Каковы ваши предпочтительные бессмысленные имена переменных? (после foo и bar) temp, res, r. На самом деле я не использую foo и bar.

Ответ 10

Какие правила вы используете для обозначения переменных?

  • Мне нужно понять это через год. Также должен соответствовать существующим стилям.

Где разрешены одиночные буквы?

  • ультра-очевидные вещи. Например. char c; c = getc(); Циклические обозначения (i, j, k).

Сколько информации вы указали в названии?

  • Много и много.

как, например, код?

  • То же, что и выше.

Каковы ваши предпочтительные бессмысленные имена переменных? (после foo и bar)

  • Мне не нравятся бессмысленные имена переменных. Если переменная ничего не значит, почему это в моем коде?

почему они пишут "foo" и "bar", а не FUBAR

  • Традиция.

Ответ 11

Правила, которыми я придерживаюсь;

Обозначает ли имя полное и точное описание того, что представляет переменная?

Указывает ли название на реальную проблему, а не на решение для программирования?

Является ли имя достаточно длинным, чтобы вам не пришлось его разгадать?

Вычислены ли квалификаторы, если они есть, в конце имени?

Являются ли они специально созданы только в точке, когда это требуется?

Ответ 12

Какие правила вы используете для обозначения переменных? camelCase для всех важных переменных, CamelCase для всех классов

Где разрешены одиночные буквы?В строках цикла и в математических функциях, где однобуквенное имя var соответствует математическому определению.

Сколько информации вы указали в названии?Вы должны уметь читать код, как книгу. Названия функций должны сообщать вам, что делает функция (scalarProd(), addCustomer() и т.д.)

Как, например, код?

Каковы ваши предпочтительные бессмысленные имена переменных? (после foo и bar)temp, tmp, input, я никогда не использую foo и bar.

Ответ 13

Я бы сказал, попробуйте назвать их как можно более четко. Никогда не используйте однобуквенные переменные и используйте только "foo" и "bar", если вы просто проверяете что-то (например, в интерактивном режиме) и не будете использовать его в процессе производства.

Ответ 14

locals: fooBar; члены/типы/функции FooBar интерфейсы: IFooBar

Как для меня, одиночные буквы действительны только в том случае, если имя классическое; i/j/k для только для индексов локального цикла, x, y, z для векторных частей.

vars имеют имена, которые передают смысл, но достаточно коротки, чтобы не обернуть строки

Foo, бар, Баз. Pickle также является фаворитом.

Ответ 15

Мне нравится префикс моих переменных с тем, что они будут: str = String, int = Integer, bool = Boolean и т.д.

Использование одной буквы выполняется быстро и легко в циклах: для я = от 0 до 4... Loop

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

Foo и Bar используются, например, для отображения кода. Вместо этого вы можете использовать практически любые бессмысленные символы. Обычно я просто использую i, x и y.

Мое личное мнение о foo bar против fu bar заключается в том, что оно слишком очевидно, и никто не любит 2-символьные переменные, 3 намного лучше!

Ответ 16

В DSL и других плавных интерфейсах часто переменные и имя метода вместе взятые образуют лексическую сущность. Например, мне лично нравится (по общему признанию еретичный) шаблон именования, где глагол помещается в имя переменной, а не в имя метода. @see 6-е правило именования переменных

Кроме того, мне нравится использование spartan $ в качестве имени переменной для основной переменной части кода. Например, класс, который красиво печатает древовидную структуру, может использовать $ для StringBuffer inst var. @see Это подробный!

В противном случае я обращаюсь к Разговору программиста Эйнаром Хостом. @see http://www.nr.no/~einarwh/phrasebook/

Ответ 17

Обновление

Во-первых, именование зависит от существующих соглашений, будь то от языка, рамки, библиотеки или проекта. (Когда в Риме...) Пример: используйте стиль jQuery для плагинов jQuery, используйте Стиль Apple для приложений iOS. Предыдущий пример требует большей бдительности (поскольку JavaScript может стать беспорядочным и не проверяется автоматически), в то время как последний пример проще, поскольку стандарт был хорошо соблюден и соблюден. YMMV в зависимости от лидеров, сообщества и особенно инструментов.

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

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

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

  • Возможность записи - общие области и шаблоны должны быть простыми (особенно если нет IDE), поэтому код проще и интереснее писать. Это немного вдохновлено стиль Роб Пике.

  • Поддержание работоспособности - если я добавлю тип к моему имени, например arrItems, то он будет сосать, если я изменил это свойство как экземпляр класса CustomSet, который расширяет Array. Заметки типа должны храниться в документации и только в случае необходимости (для API и т.д.).

  • Стандартное, общее присвоение имен - для немых сред (текстовые редакторы): классы должны быть в ProperCase, переменные должны быть короткими и, если необходимо, в snake_case, а функции должны быть в camelCase.

Для JavaScript это классический случай ограничений языка и инструментов, влияющих на именование. Это помогает отличать переменные от функций посредством различного наименования, так как нет IDE, чтобы держать руку в то время как this и prototype, а другой шаблон скрывает ваше видение и путает ваши навыки дифференциации. Также нередко видеть, что все несущественные или глобально полученные вары в области сокращаются. Язык не имеет import [path] as [alias];, поэтому локальные вары становятся псевдонимами. И затем там множество различных условных условных обозначений. Единственное решение здесь (и где угодно, действительно) - это правильная документация о намерениях (и идентичности).

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

Ответ 18

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

Многое зависит от языка, в котором вы программируете, я не называю переменные одинаковыми в С++, как в Java (Java лучше подходит к слишком длинным именам переменных imo, но это может быть просто личное предпочтение. Или это может иметь какое-то отношение к тому, как названы Java-встроенные модули...).

Ответ 19

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

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

for (int firstStageRocketEngineIndex = 0; firstStageRocketEngineIndex < firstStageRocketEngines.Length; firstStageRocketEngineIndex++)
{
  firstStageRocketEngines[firstStageRocketEngineIndex].Ignite();
  Thread.Sleep(100);  // Don't start them all at once. That would be bad.
}

Ответ 20

Не так важно, как вы называете переменные. Вам действительно не нужны никакие правила, кроме тех, которые указаны языком или, как минимум, теми, которые выполняются вашим компилятором.

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

Ответ 21

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

Итак, если вы не можете найти точки, в которых они не согласны, я смотрю официальные рекомендации Microsoft Net для последовательного набора имен конвенций.

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

.

Ответ 22

  • Используйте переменные, которые четко описывают, что он содержит. Если класс станет большим или если он находится в общедоступной области, то имя переменной должно быть описано более точно. Разумеется, хорошее именование позволяет вам и другим людям лучше понимать код.
    • например: используйте "employeeNumber", чтобы указать только "число".
    • используйте Btn или Button в конце имени переменных, относящихся к кнопкам.
  • Запуск переменных с нижним регистром, запуск классов с прописными буквами.
    • пример класса "MyBigClass", пример переменной "myStringVariable"
  • Используйте верхний регистр, чтобы указать новое слово для лучшей читаемости. Не используйте "_", потому что он выглядит уродливее и занимает больше времени для записи.
    • например: используйте "employeeName".
  • Используйте только одиночные символьные переменные в циклах.

Ответ 23

Я работаю в MathCAD, и я счастлив, потому что MathCAD дает мне возможности для именования, и я использую их много. И я не могу понять, как программировать без этого. Чтобы отличать один var от другого, я должен включать в него много информации, например:

1. На первом месте - то есть -N для величины, F для силы и т.д.

2. Во втором - дополнительные индексы - для направления силы, например

3. В третьей - индексация внутри вектора или матрицы var, для удобства я помещаю имя var в скобки {} или [], чтобы показать его размеры.

Итак, как вывод, мое имя var похоже N.dirs/Fx i.row/{F}.w. (I, j.k)/{F}.w. (K, i.j). Иногда мне нужно добавить имя системы координат для векторных значений {F}. {GCS}.w. (I, j.k)/{F}. {LCS}.w. (I, j.k)

И в качестве последнего шага я добавляю имя внешнего модуля в BOLD в конце внешней функции или var как Row.MTX.f([M]), потому что у MathCAD нет строки справки для функции.

Ответ 24

В настоящее время я делаю много php, это было не всегда так, но я узнал несколько трюков, когда дело доходит до имен переменных.

//это моя строковая переменная $ strVar = "";

//это будет представлять массив $ arrCards = array();

//это для целого числа $ intTotal = NULL:

//объект $ objDB = new database_class();

//булево $ blValid = true;