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

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

Предоставьте примерные циклы!

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

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

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

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

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

     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 ? - отклоненные альтернативы

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

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

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

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

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

    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: нажмите здесь

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

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

    Non-Nested Loops:. , , Индекс – это значение.

    , , , использование 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 Loops:. , , Object требуется имя.

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

     for (Object something : somethings) { // LOOP_BODY } 

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

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

    , , , iter сокращает цель iteratorов . , ,

     for (Iterator iter = collection.iterator(); iter.hasNext(); /* N/A */) { Object object = iter.next(); // LOOP_BODY } 

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

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

     /* LOOP_DESCRIPTION */ { Iterator iter = collection.iterator(); while (iter.hasNext()) { // LOOP_BODY } } 

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

    Мой опыт в том, что большинство людей используют одиночные буквы, например: 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 встречается довольно часто в коде, где это не переменная, которую вы ищете.

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

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

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

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

    i

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

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

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

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

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

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

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

     foreach widget in widgets do foo(widget) end 

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

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

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

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

    Стандарт Perl

    В Perl стандартное имя переменной для внутреннего цикла равно $ _ . Операторы for , 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 , а не $ _ или описательное имя. Например, полезно сопоставить переменные в опубликованном алгоритме, таком как перекрестный продукт .

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

    @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» моими сверстниками.

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

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

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

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

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

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

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

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

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

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

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

     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.

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

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

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

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

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

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

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

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

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

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

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

    Мои личные

    индекс первый, счетчик вторых счетчиков

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

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

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

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

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

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

    Давайте будем гением компьютера.