Что такое идеальное соглашение об именах переменных для переменных цикла?

Если вы пишете простой маленький цикл, что вы должны назвать счетчиком?

Приведите примеры циклов!

ОТВЕТЫ

Ответ 1

1) Для обычных маленьких стилей старого стиля - i, j, k - Если вам требуется более трех уровней вложенных циклов, это означает, что либо алгоритм очень специфичен и сложный, либо вы должны рассмотреть возможность реорганизации кода.

Пример Java:

for(int i = 0; i < ElementsList.size(); i++) {
  Element element = ElementsList.get(i);
  someProcessing(element);
  ....
}

2) Для новых java-циклов стиля, подобных for(Element element: ElementsList), лучше использовать нормальное значащее имя

Пример Java:

for(Element element: ElementsList) {
  someProcessing(element);
  ....
}

3) Если это возможно с использованием используемого вами языка, преобразуйте цикл для использования iterator

Пример Java Iterator: нажмите здесь

Ответ 2

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

При использовании значимых имен:

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

Пример - укажите ошибку

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

int values[MAX_ROWS][MAX_COLS];

int sum_of_all_values()
{
    int i, j, total;

    total = 0;
    for (i = 0; i < MAX_COLS; i++)
        for (j = 0; j < MAX_ROWS; j++)
             total += values[i][j];
    return total;
}

тогда как при использовании значимых имен проще:

int values[MAX_ROWS][MAX_COLS];

int sum_of_all_values()
{
    int row_num, col_num, total;

    total = 0;
    for (row_num = 0; row_num < MAX_COLS; row_num++)
        for (col_num = 0; col_num < MAX_ROWS; col_num++)
             total += values[row_num][col_num];
    return total;
}

Почему row_num? - отклоненные альтернативы

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

  • r и c: это немного лучше, чем i и j. Я бы рассматривал их только в том случае, если бы мой стандарт организации был для однобуквенных переменных целыми числами, а также всегда был первой буквой эквивалентного описательного имени. Система упадет, если у меня есть две переменные в функции, имя которой начинается с "r", и читаемость пострадает, даже если другие объекты, начинающиеся с "r", появятся где-нибудь в коде.
  • rr и cc. Это выглядит странно для меня, но я не привык к шаблону переменной с двумя буквами. Если бы это было стандартом в моей организации, то я предполагаю, что это будет немного лучше, чем r и c.
  • row и col. На первый взгляд это кажется более кратким, чем row_num и col_num, и так же описательно. Тем не менее, я ожидал бы, что голые существительные типа "строка" и "столбец" будут ссылаться на структуры, объекты или указатели на них. Если row может означать либо сама структура строки, либо номер строки, тогда возникает путаница.
  • iRow и iCol. Это передает дополнительную информацию, так как i может означать, что это счетчик цикла, в то время как row и col сообщают вам что он считает. Тем не менее, я предпочитаю читать код почти на английском языке:
    • row_num < MAX_COLS читается как " строка num ber меньше max imum (число) col strong > итп s";
    • iRow < MAX_COLS в лучшем случае читает как "счетчик целых чисел для строки меньше max > imum (число) col umn s".
    • Это может быть личная вещь, но я предпочитаю первое чтение.

Альтернативой row_num я бы принял: row_idx: слово "index" однозначно ссылается на позицию массива, если домен приложения не находится в дизайне базы данных, финансовых рынках и т.д.

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

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

Ответ 3

Примеры:., В Java


Нетерабельные петли:


Не вложенные петли:., Индекс - это значение.

., использование i, как и в Алгебре, является наиболее распространенной практикой.,.

for (int i = 0; i < LOOP_LENGTH; i++) {

    // LOOP_BODY
}


Вложенные петли:., Дифференцирующие индексы придают понимание.

., используя описательный суффикс.,.

for (int iRow = 0; iRow < ROWS; iRow++) {

    for (int iColumn = 0; iColumn < COLUMNS; iColumn++) {

        // LOOP_BODY
    }
}


foreach Циклы:., Для параметра Object требуется имя.

., используя описательное имя.,.

for (Object something : somethings) {

    // LOOP_BODY
}


Итеративные петли:


for Циклы:., Итераторы ссылаются на объекты. Итератором это не так; Индекса или Индекса.

., iter устраняет цель итераторов.,.

for (Iterator iter = collection.iterator(); iter.hasNext(); /* N/A */) {

    Object object = iter.next();

    // LOOP_BODY
}


while Циклы:., Ограничьте область действия итератора.

., комментируя назначение петель.,.

/* LOOP_DESCRIPTION */ {

    Iterator iter = collection.iterator();

    while (iter.hasNext()) {

        // LOOP_BODY
    }
}

Этот последний пример плохо читается без комментариев, тем самым поощряя их. Это, возможно, многословно, но полезно в области ограничения циклов в C.

Ответ 4

Мой опыт в том, что большинство людей используют отдельные буквы, например: i j k ... или x y или r c (для строки/столбца) или w, h (для ширины/высоты) , и т.д.

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

// recommended style              ●    // "typical" single-letter style
                                  ●
for (ii=0; ii<10; ++ii) {         ●    for (i=0; i<10; ++i) {
    for (jj=0; jj<10; ++jj) {     ●        for (j=0; j<10; ++j) {
        mm[ii][jj] = ii * jj;     ●             m[i][j] = i * j;
    }                             ●        }
}                                 ●    }

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

Ответ 5

Всегда пытайтесь назвать переменную чем-то значимым и в контексте.

Если вы не можете решить, тогда используйте "index", если только для того, чтобы кто-то еще (может быть, вы!) более легко щелкнул по нему для рефакторинга позже.

Пол Стивенсон См. этот ответ для примера.

Ответ 6

Я использую i, j, k (или r и c для циклического цикла строк). Если вам нужен более трех переменных цикла в методе, этот метод, вероятно, слишком длинный и сложный, и ваш код, скорее всего, получит выгоду от разделения метода вверх на большее количество методов и присвоить имена им правильно.

Ответ 7

i

если у меня есть вложенный цикл, а затем j.

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

Ответ 8

Я использую i, ii, iii, iv, v... Никогда не получал выше, чем iii.

Ответ 9

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

Ответ 10

Если счетчик должен использоваться как индекс для контейнера, я использую i, j, k.

Если он используется для итерации по диапазону (или выполнения заданного количества итераций), я часто использую n. Хотя, если требуется вложение, я обычно вернусь к i, j, k.

В языках, которые предоставляют конструкцию foreach -style, я обычно пишу так:

foreach widget in widgets do
  foo(widget)
end

Я думаю, что некоторые люди скажут мне про именование widget так же, как и widgets, но я считаю его вполне читаемым.

Ответ 11

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

Ответ 12

Стив Макконнелл Code Complete имеет, как обычно, отличный совет в этом отношении. Соответствующие страницы (в первом издании в любом случае) равны 340 и 341. Определенно советуйте всем, кто заинтересован в улучшении их кодирования в цикле, чтобы придать этому вид. McConnell рекомендует значащие имена счетчиков циклов, но люди должны читать то, что он получил, чтобы сказать сами, а не полагаться на мое слабое резюме.

Ответ 13

Я использую "counter" или "loop" как имя переменной. Современные IDE обычно выполняют завершение слова, поэтому более длинные имена переменных не так утомительны в использовании. Кроме того, чтобы назвать переменную своей функциональностью, она дает понять программисту, который будет поддерживать ваш код в отношении ваших намерений.

Ответ 14

Я давно использовал схему именования i/j/k. Но в последнее время я начал адаптировать более последовательный метод именования.

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

В соответствии с запросом несколько примеров:

Если вам нужна петля через коллекцию элементов.

for (int currentItemIndex = 0; currentItemIndex < list.Length; currentItemIndex++)
{
    ...
}

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

Item currentItem = list[currentItemIndex];

Я пытаюсь использовать конструкцию foreach для языка. который преобразует.

for (int currentItemIndex = 0; currentItemIndex < list.Length; currentItemIndex++)
{
    Item currentItem = list[currentItemIndex];
    ...
}

в

foreach (Item currentItem in list)
{
   ...
}

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

Единственный раз, когда я по-прежнему использую однобуквенные переменные, - это когда я занимаюсь измерениями прорубей. Но тогда я буду использовать x, y и иногда z.

Ответ 15

Стандарт Perl

В Perl стандартное имя переменной для внутреннего цикла $_. Операторы для, foreach и while по умолчанию используют эту переменную, поэтому вам не нужно ее объявлять. Обычно $_ может читаться как родовое местоимение "it". Итак, довольно стандартный цикл может выглядеть так:

foreach (@item){
    $item_count{$_}++;
}

На английском языке это означает:

Для каждого элемента добавьте его item_count.

Тем не менее, более распространенным является не использование переменной вообще. Многие функции и операторы Perl по умолчанию имеют значение $_: 
for (@item){
    print;
}

На английском языке:

Для пункта [each] напечатайте [it].

Это также стандарт для счетчиков. (Но счетчики используются гораздо реже в Perl, чем на других языках, таких как C). Поэтому для печати квадратов целых чисел от 1 до 100:

for (1..100){
    print "$_*$_\n";
}

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

Для каждого автомобиля посмотрите на каждую шину и проверьте ее давление.

В Perl:

foreach $car (@cars){
    for (@{$car->{tires}}){
        check_pressure($_);
    }
}

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

Иногда имеет смысл использовать более короткие, не описательные, общие имена, такие как $i, $j и $k, а не $_ или описательное имя. Например, полезно использовать переменные в опубликованном алгоритме, например cross product.

Ответ 16

@JustMike., НЕПРАВИЛЬНЫЕ ПРИМЕРЫ:., для сопровождения Java.

Цикл NON-NESTED:., ограничение по возможности

/*LOOP_DESCRIPTION*/ {

    int i;

    for (i = 0; i < LOOP_LENGTH; i++) {

        // loop body
    }  
}


Цикл NESTED:., то же самое

/*LOOP_DESCRIPTION*/ {

    int row, column;

    for (row = 0; row < ROWS; row++) {

        for (column = 0; column < COLUMNS; column++) {

            // loop body
        }
    }  
}

Одна хорошая вещь в этом макете - это плохо читать без комментариев, тем самым поощряя их.
Это может быть, возможно, но лично это то, как я делаю петли на C.

Кроме того: когда я начал, я использовал "index" и "idx", но это обычно менялось на "i" моими сверстниками.

Ответ 17

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

Ответ 18

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

for (i = 0; i < count; i++) ...

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

Аналогично, если вы просматриваете 2d-массив пикселей, например, вы можете написать

for (y = 0; y < height; y++)
  for (x = 0; x < width; x++)
    ...

Просто сделайте то же самое в каждом месте, где вы пишете этот тип цикла.

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

Ответ 19

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

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

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

Ответ 20

Я начал использовать perlisms в php.

если его особая итерация $_ является хорошим именем для тех, кто знает ее использование.

Ответ 21

Моя привычка состоит в том, чтобы использовать 't' - близко к 'r', поэтому он легко следует после ввода 'for'

Ответ 22

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

Ответ 23

Я начал использовать контекстно-зависимые имена переменных цикла, смешанные с hungarian.

При переходе по строкам я использую iRow. При переходе по столбцам я использую iCol. При переходе через автомобили я буду использовать iCar. Вы получаете идею.

Ответ 24

для численных вычислений, matlab и подобных ему, не используйте i, j

это зарезервированные константы, но Matlab не будет жаловаться.

Мои личные favs

индекс первая секунда счетчик кол

Ответ 25

Мое любимое соглашение для петли над матричным набором - использовать x + y, поскольку они используются в декартовых координатах:

for x in width:
    for y in height:
        do_something_interesting(x,y)

Ответ 26

Я обычно использую:

for(lcObject = 0; lcObject < Collection.length(); lcObject++)
{
   //do stuff
}

Ответ 27

Для целых чисел я использую int index, если он не вложен, тогда я использую индексный суффикс над тем, что повторяется как int groupIndex и int userIndex.

Ответ 28

В Python я использую i, j и k, если я только время подсчитываю. Я использую x, y и z, если счетчик итераций используется в качестве индекса. Однако, если я действительно создаю ряд аргументов, я буду использовать значащее имя.