blocks|key|1527923|text|如果您将其命名为描述其循环内容的名称，则会有所帮助。但我通常只用i。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1527924|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It helps if you name it something that describes what it is looping through. But I usually just use i.

blocks|key|1527950|text|我绝对是可以接受的。不确定我需要做出什么样的理由--但我确实一直在使用它，其他非常受尊敬的程序员也是这样做的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1527951|社交验证，我猜:)|1527952|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

i is definitely acceptable. Not sure what kind of justification I need to make -- but I do use it all of the time, and other very respected programmers do as well.

Social validation, I guess :)

blocks|key|1527965|text|是的，事实上它是首选的，因为任何阅读你的代码的程序员都会明白它只是一个迭代器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1527966|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes, in fact it's preferred since any programmer reading your code will understand that it's simply an iterator.

blocks|key|1527983|text|只要您使用i来计算循环数，或者是从0(或1，取决于PL)到n的索引的一部分，那么我会说我很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1527984|否则，可能很容易给I命名一些有意义的东西，它不仅仅是一个索引。|1527985|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

As long as you are either using i to count loops, or part of an index that goes from 0 (or 1 depending on PL) to n, then I would say i is fine.

Otherwise its probably easy to name i something meaningful it its more than just an index.

blocks|key|1743032|text|如果“更具语义的东西”是“迭代器”，那么没有理由不使用i；这是一个很好理解的成语。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1743033|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If the "something more semantic" is "iterator" then there is no reason not to use i; it is a well understood idiom.

blocks|key|1743058|text|我倾向于使用i，j，k来表示非常局部化的循环(仅在源代码行的数量方面存在一小段时间)。对于存在于较大源代码区域的变量，我倾向于使用更详细的名称，这样我就可以了解它们的用途，而不需要重新搜索代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1743059|顺便说一下，我认为这些变量的命名约定来自早期的Fortran语言，当时我是第一个整数变量(A+-H是浮点数)？|1743060|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I tend to use i, j, k for very localized loops (only exist for a short period in terms of number of source lines). For variables that exist over a larger source area, I tend to use more detailed names so I can see what they're for without searching back in the code.

By the way, I think that the naming convention for these came from the early Fortran language where I was the first integer variable (A - H were floats)?

blocks|key|1743079|text|这是另一个完全没问题的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1743080|foreach+(Product+p+in+ProductList)
{
++++//+Do+something+with+p
}|code-block|syntax|javascript|1743081|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's another example of something that's perfectly okay:

<pre><code>foreach (Product p in ProductList)
{
 // Do something with p
}
</code></pre>

blocks|key|1528086|text|我应该指出的是，i和j也是矩阵索引的数学符号。通常，你会遍历一个数组。所以这是有道理的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1528087|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I should point out that i and j are also mathematical notation for matrix indices. And usually, you're looping over an array. So it makes sense.

blocks|key|1743142|text|我想这要看上下文了。如果你正在循环通过某个集合中的一组对象，那么从上下文中你所做的事情应该是相当明显的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1743143|for(int+i+=+0;+i+<+10;+i%2B%2B)
{
++++//+i+is+well+known+here+to+be+the+index
++++objectCollection[i].SomeProperty+=+someValue;
}|code-block|syntax|javascript|1743144|但是，如果不能立即从上下文中清楚您在做什么，或者如果您正在对索引进行修改，您应该使用更能指示用法的变量名。|1743145|for(int+currentRow+=+0;+currentRow+<+numRows;+currentRow%2B%2B)
{
++++for(int+currentCol+=+0;+currentCol+<+numCols;+currentCol%2B%2B)
++++{
++++++++someTable[currentRow][currentCol]+=+someValue;
++++}
}+|1743146|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Depends on the context I suppose. If you where looping through a set of Objects in some 
collection then it should be fairly obvious from the context what you are doing.

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

However if it is not immediately clear from the context what it is you are doing, or if you are making modifications to the index you should use a variable name that is more indicative of the usage.

<pre><code>for(int currentRow = 0; currentRow &lt; numRows; currentRow++)
{
 for(int currentCol = 0; currentCol &lt; numCols; currentCol++)
 {
 someTable[currentRow][currentCol] = someValue;
 }
} 
</code></pre>

blocks|key|1528182|text|只要你在一个简单的循环中暂时使用它，并且你在做什么是显而易见的，当然。也就是说，有没有其他短词可以代替呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1528183|众所周知，i是一种循环迭代器，因此如果在循环之外使用它，实际上更有可能使维护程序员感到困惑，但如果使用更具描述性的东西(如filecounter)，它会使代码更好。|offset|length|style|CODE|1528184|entityMap^0|0|5|1|1P|B|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

As long as you're using it temporarily inside a simple loop and it's obvious what you're doing, sure. That said, is there no other short word you can use instead?

<code>i</code> is widely known as a loop iterator, so you're actually more likely to confuse maintenance programmers if you use it outside of a loop, but if you use something more descriptive (like <code>filecounter</code>), it makes code nicer.

blocks|key|1743253|text|使用i而不是更具体的变量名有什么意义？为了节省1秒或10秒，或者甚至30秒的思考和打字时间？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1743254|使用i的成本是多少？也许什么都没有。也许代码太简单了，所以使用i就可以了。但是，也许，也许，使用I将迫使将来使用此代码的开发人员考虑一下“我在这里是什么意思？”他们必须思考：“它是一个索引，一个计数，一个偏移量，还是一个标志？”他们将不得不思考：“这个变化是安全的吗，它是正确的吗，我会在1点之前离开吗？”|1743255|使用i可以节省编写代码时的时间和精力，但在未来可能会耗费更多的精力，甚至可能由于误解代码而导致无意中引入缺陷。|1743256|一般来说，大多数软件开发都是维护和扩展，因此阅读代码所花费的时间将大大超过编写代码所花费的时间。|1743257|养成在任何地方使用有意义的名称的习惯是很容易的，一旦你养成了这个习惯，用有意义的名称编写代码只需要几秒钟，但这样你的代码就更容易阅读，更容易理解，更明显地正确。|1743258|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

What is the value of using i instead of a more specific variable name? To save 1 second or 10 seconds or maybe, maybe, even 30 seconds of thinking and typing?

What is the cost of using i? Maybe nothing. Maybe the code is so simple that using i is fine. But maybe, maybe, using i will force developers who come to this code in the future to have to think for a moment "what does i mean here?" They will have to think: "is it an index, a count, an offset, a flag?" They will have to think: "is this change safe, is it correct, will I be off by 1?"

Using i saves time and intellectual effort when writing code but may end up costing more intellectual effort in the future, or perhaps even result in the inadvertent introduction of defects due to misunderstanding the code.

Generally speaking, most software development is maintenance and extension, so the amount of time spent reading your code will vastly exceed the amount of time spent writing it.

It's very easy to develop the habit of using meaningful names everywhere, and once you have that habit it takes only a few seconds more to write code with meaningful names, but then you have code which is easier to read, easier to understand, and more obviously correct.

blocks|key|1528266|text|那得看情况。如果您正在迭代某些特定的数据集，那么我认为使用描述性名称会更有意义。(例如，按照丹的建议，使用filecounter+)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1528267|但是，如果您正在执行任意循环，那么i是可以接受的。正如一位同事向我描述的那样--+i是一种约定，意思是“这个变量只会被for循环结构修改。如果不是这样，就不要使用i”。|1528268|entityMap^0|1H|B|0|H|1|15|1|1N|3|29|1|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$]]

It depends.
If you're iterating over some particular set of data then I think it makes more sense to use a descriptive name. (eg. <code>filecounter</code> as Dan suggested).

However, if you're performing an arbitrary loop then <code>i</code> is acceptable. As one work mate described it to me - <code>i</code> is a convention that means "this variable is only ever modified by the <code>for</code> loop construct. If that's not true, don't use <code>i</code>"

blocks|key|1528290|text|i，j，k用于整数循环计数器的使用可以追溯到FORTRAN的早期。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1528291|就我个人而言，只要它们是整数计数，我就不会有任何问题。|1528292|但是后来我在FORTRAN上长大了！|1528293|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The use of i, j, k for INTEGER loop counters goes back to the early days of FORTRAN. 
Personally I don't have a problem with them so long as they are INTEGER counts. 
But then I grew up on FORTRAN!

blocks|key|1743342|text|I是如此常见，甚至对于喜欢描述性变量名的人来说也是可以接受的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1743343|在任何其他上下文中使用i、j或k，而不是作为循环中的整数索引，这是绝对不可接受的(在我的书中也是一种罪过)……例如：|1743344|foreach(Input+i+in+inputs)
{
++++Process(i);

}|code-block|syntax|javascript|1743345|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

i is so common that it is acceptable, even for people that love descriptive variable names.

What is absolutely unacceptable (and a sin in my book) is using i,j, or k in any other context than as an integer index in a loop.... e.g.

<pre><code>foreach(Input i in inputs)
{
 Process(i);

}
</code></pre>

blocks|key|1528378|text|我认为我在for循环的情况下是完全可以接受的。我总是发现这是非常标准的，当我在这种情况下使用时，从来没有遇到过解释问题。foreach循环变得有点棘手，我认为这真的取决于您的情况。我很少在foreach中使用i，只在for循环中使用，因为我发现在这些情况下我太难以描述了。对于foreach，我尝试使用正在循环的对象类型的缩写。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1528379|foreach(DataRow+dr+in+datatable.Rows)
{
++++//do+stuff+to/with+datarow+dr+here
}|code-block|syntax|javascript|1528380|不管怎样，只要我的0.02美元。|1528381|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

i think i is completely acceptable in for-loop situations. i have always found this to be pretty standard and never really run into interpretation issues when i is used in this instance. foreach-loops get a little trickier and i think really depends on your situation. i rarely if ever use i in foreach, only in for loops, as i find i to be too un-descriptive in these cases. for foreach i try to use an abbreviation of the object type being looped. e.g:

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

anyways, just my $0.02.

blocks|key|1743433|text|我要违背常理，说不。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1743434|对于那些说“我被理解为迭代器”的人来说，这可能是真的，但对我来说，这等同于“将值5赋给变量Y”之类的注释。像注释这样的变量名称应该解释为什么/什么而不是如何。|1743435|要使用上一个答案中的示例：|1743436|for(int+i+=+0;+i+<+10;+i%2B%2B)
{
++++//+i+is+well+known+here+to+be+the+index
++++objectCollection[i].SomeProperty+=+someValue;
}|code-block|syntax|javascript|1743437|仅仅使用一个像这样有意义的名字有那么难吗？|1743438|for(int+objectCollectionIndex+=+0;+objectCollectionIndex++<+10;+objectCollectionIndex+%2B%2B)
{
++++objectCollection[objectCollectionIndex].SomeProperty+=+someValue;
}|1743439|当然，(借用的)变量名objectCollection的命名也很糟糕。|1743440|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I am going to go against the grain and say no. 

For the crowd that says "i is understood as an iterator", that may be true, but to me that is the equivalent of comments like 'Assign the value 5 to variable Y. Variable names like comment should explain the why/what not the how.

To use an example from a previous answer:

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

Is it that much harder to just use a meaningful name like so?

<pre><code>for(int objectCollectionIndex = 0; objectCollectionIndex &lt; 10; objectCollectionIndex ++)
{
 objectCollection[objectCollectionIndex].SomeProperty = someValue;
}
</code></pre>

Granted the (borrowed) variable name objectCollection is pretty badly named too.

As far as variable naming conventions go, should iterators be named <code>i</code> or something more semantic like <code>count</code>? If you don't use <code>i</code>, why not? If you feel that <code>i</code> is acceptable, are there cases of iteration where it shouldn't be used?

Is a variable named i unacceptable?

软件开发

就变量命名约定而言，迭代器应该命名为i还是更具语义的名称，比如count？如果你不使用i，为什么不呢？如果您觉得i是可以接受的，那么是否存在不应该使用它的迭代情况？

问名为i的变量不可接受吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问名为i的变量不可接受吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问名为i的变量不可接受吗？
EN