Является ли переменная я недопустимой?

Ответ 1

Зависит от контекста, который я предполагаю. Если вы выполняете цикл через набор объектов в некоторых коллекции, то это должно быть достаточно очевидно из контекста, что вы делаете.

for(int i = 0; i < 10; i++)
{
    // i is well known here to be the index
    objectCollection[i].SomeProperty = someValue;
}

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

for(int currentRow = 0; currentRow < numRows; currentRow++)
{
    for(int currentCol = 0; currentCol < numCols; currentCol++)
    {
        someTable[currentRow][currentCol] = someValue;
    }
} 

Ответ 2

"i" означает "счетчик циклов" для программиста. Там нет ничего плохого.

Ответ 3

Вот еще один пример чего-то совершенно нормально:

foreach (Product p in ProductList)
{
    // Do something with p
}

Ответ 4

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

Кстати, я считаю, что соглашение об именах для них исходило из раннего языка Fortran, где я был первой целочисленной переменной (A-H - float)?

Ответ 5

i допустим, наверняка. Тем не менее, я изучил огромное количество одного семестра от учителя С++, у которого было, кто отказался от кода, у которого не было описательного имени для каждой отдельной переменной. Простой акт обозначения всего описательно заставил меня больше думать о моем коде, и после этого курса я написал лучшие программы, а не учебу на С++, а от обучения, чтобы назвать все. Code Complete имеет несколько хороших слов по этой же теме.

Ответ 6

i отлично, но что-то вроде этого не есть:

for (int i = 0; i < 10; i++)
{
    for (int j = 0; j < 10; j++)
    {
        string s = datarow[i][j].ToString(); // or worse
    }
}

Очень часто для программистов непреднамеренно заменять я и j в коде, особенно если у них плохое зрение или их тема Windows - "hotdog". Это всегда "запах кода" для меня - это редкий случай, когда это не прикручивается.

Ответ 7

i настолько распространен, что это приемлемо даже для людей, которые любят описательные имена переменных.

Что абсолютно неприемлемо (и грех в моей книге) использует i, j или k в любом другом контексте, чем как целочисленный индекс в цикле... например.

foreach(Input i in inputs)
{
    Process(i);

}

Ответ 8

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

Социальная валидация, я думаю:)

Ответ 9

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

Ответ 10

Каково значение использования я вместо более конкретного имени переменной? Чтобы сохранить 1 секунду или 10 секунд или, может быть, даже 30 секунд мышления и ввода?

Какова стоимость использования i? Может быть, ничего. Возможно, код настолько прост, что использование я в порядке. Но, может быть, возможно, используя, я заставил разработчиков, которые приходят в этот код в будущем, подумать на мгновение: "Что я имею в виду здесь?" Им придется подумать: "Это индекс, счет, смещение, флаг?" Им придется подумать: "Это безопасное изменение, правильно ли, я отключусь на 1?"

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

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

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

Ответ 11

Я использую я для коротких циклов.

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

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

Я не использую i, если:

• Тело цикла не мало или
• итератор выполняет что-либо другое, кроме перехода (или отступления) от начала диапазона до конца цикла:

i не обязательно нужно вводить с шагом 1, если приращение является последовательным и понятным и, конечно, может остановиться до конца итерации, но если оно когда-либо изменит направление или не будет изменено путем итерации цикла (включая дьявольское использование iterator.insertAfter() в прямом цикле), я стараюсь не забывать использовать что-то другое. Это означает, что "это не просто тривиальная переменная цикла, следовательно, это может быть не тривиальная петля".

Ответ 12

Если "что-то более смысловое" является "итератором", тогда нет причин не использовать i; это хорошо понятая идиома.

Ответ 13

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

foreach(DataRow dr in datatable.Rows)
{
    //do stuff to/with datarow dr here
}

в любом случае, только мои $0,02.

Ответ 14

Это помогает, если вы назовете его чем-то, что описывает то, что он перебирает. Но я обычно использую i.

Ответ 15

Пока вы используете я для подсчета циклов или часть индекса, который идет от 0 (или 1 в зависимости от PL) до n, тогда я бы сказал, что я в порядке.

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

Ответ 16

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

Ответ 17

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

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

Ответ 18

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

Однако, если вы выполняете произвольный цикл, то i допустимо. Поскольку один из соавторов описал это мне - i - это соглашение, которое означает, что эта переменная модифицируется только конструкцией цикла for. Если это не так, не используйте i "

Ответ 19

Использование i, j, k для счетчиков циклов INTEGER восходит к началу FORTRAN. Лично у меня нет проблем с ними, пока они являются подсчетами INTEGER.
Но потом я вырос на ФОРТРАНЕ!

Ответ 20

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

я спросил аналогичный вопрос на прошлой неделе, а следующее - мой собственный ответ:

// 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;
    }                             ●        }
}                                 ●    }

Я делал это так в течение как минимум 10 лет.

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

Ответ 21

Я собираюсь пойти против зерна и сказать "нет".

Для толпы, которая говорит, что "я понимается как итератор", это может быть правдой, но для меня это эквивалент комментариев, таких как "Назначить значение 5 переменной Y. Имена переменных, такие как комментарий, должны объяснять, почему/что не так.

Чтобы использовать пример из предыдущего ответа:

for(int i = 0; i < 10; i++)
{
    // i is well known here to be the index
    objectCollection[i].SomeProperty = someValue;
}

Насколько сложнее просто использовать значащее имя?

for(int objectCollectionIndex = 0; objectCollectionIndex  < 10; objectCollectionIndex ++)
{
    objectCollection[objectCollectionIndex].SomeProperty = someValue;
}

Предоставлено (заимствованное) имя переменной objectCollection довольно плохо названо.