language agnostic - ¿Cuál es una convención ideal de nomenclatura variable para variables de bucle?

language-agnostic naming-conventions

Question

Si está escribiendo un pequeño bucle simple , ¿cómo debe nombrar el contador?

Proporcione bucles de ejemplo!

Answer 1

Estándar Perl

En Perl, el nombre de variable estándar para un bucle interno es $ _ . Las instrucciones for , foreach y while están predeterminadas para esta variable, por lo que no es necesario que la declare. Por lo general, $ _ puede leerse como el pronombre genérico neutro "eso". Así que un bucle bastante estándar podría verse así:

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

En inglés, eso se traduce a:

Para cada elemento, incremente su item_count.

Aún más común, sin embargo, es no usar una variable en absoluto. Muchas funciones y operadores de Perl tienen por defecto $ _ :

for (@item){
    print;
}

En inglés:

Para [cada] elemento, imprímalo [it].

Este también es el estándar para contadores. (Pero los contadores se utilizan con mucha menos frecuencia en Perl que en otros idiomas, como C). Entonces, para imprimir los cuadrados de enteros de 1 a 100:

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

Como solo un ciclo puede usar la variable $ _ , generalmente se usa en el ciclo más interno. Este uso coincide con la forma en que el inglés generalmente funciona:

Para cada automóvil, mire cada llanta y verifique su presión.

En Perl:

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

Como se indicó anteriormente, es mejor utilizar nombres descriptivos más largos en bucles externos, ya que puede ser difícil recordar en un bloque largo de código lo que realmente significa un nombre de variable de bucle genérico.

Ocasionalmente, tiene sentido utilizar nombres genéricos más cortos y no descriptivos, como $ i , $ j y $ k , en lugar de $ _ o un nombre descriptivo. Por ejemplo, es útil hacer coincidir el uso de variables en un algoritmo publicado, como producto cruzado .

Answer 2

Al igual que en un póster anterior, también uso ii, jj, .. principalmente porque en muchas fuentes, una sola parece muy similar a 1.

Answer 3

Empecé a usar perlismos en php.

si es una iteración singular, $_ es un buen nombre para aquellos que conocen su uso.

Answer 4

Mi hábito es usar ''t'', cerca de ''r'', por lo que se puede escribir fácilmente después de ''tipear''

Answer 5

Si el contador se va a utilizar como índice de un contenedor, uso i , j , k .

Si se va a utilizar para iterar sobre un rango (o realizar un número de iteraciones), a menudo uso n . Sin embargo, si se requiere anidar normalmente volveré a i , j , k .

En los lenguajes que proporcionan un constructo estilo foreach , generalmente escribo así:

foreach widget in widgets do
  foo(widget)
end

Creo que algunas personas me regañarán por nombrar el widget manera similar a los widgets , pero me parece bastante legible.

Answer 6

Si es un contador simple, me atengo a usar ''i''; de lo contrario, tengo un nombre que denota el contexto. Tiendo a mantener la longitud variable en 4. Esto es principalmente desde el punto de vista de lectura del código, la escritura no cuenta ya que tenemos la función de autocompletar.

Answer 7

Uso letras sueltas solo cuando el contador de bucles es un índice. Me gusta el pensamiento detrás de la doble letra, pero hace que el código sea ilegible.

Answer 8

Yo uso "contador" o "lazo" como el nombre de la variable. Los IDE modernos generalmente completan la palabra, por lo que los nombres de variable más largos no son tan tediosos de usar. Además, nombrar la variable a su funcionalidad deja en claro al programador quién va a mantener su código en cuanto a cuáles eran sus intenciones.

Answer 9

Yo uso i, ii, iii, iv, v ... Sin embargo, nunca supere el iii.

Answer 10

i

si tengo un bucle anidado, entonces también j .

Esta convención es tan común que si te las arreglas para encontrar una variable i en un bloque de código que no puedes ver al principio, aún la reconoces instantáneamente por lo que es.

Answer 11

@JustMike. . . ALGUNOS EJEMPLOS DE C: . . para acompañar a los de Java.

Bucle no anidado:. . . limitar el alcance donde sea posible

/*LOOP_DESCRIPTION*/ {

    int i;

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

        // loop body
    }  
}

ANILLO NESTED:. . . ídem

/*LOOP_DESCRIPTION*/ {

    int row, column;

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

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

            // loop body
        }
    }  
}

Una cosa buena de este diseño es que se lee mal sin comentarios, lo que los alienta.
Es verboso quizás, pero personalmente así es como hago los loops en C.

Además: utilicé "index" e "idx" cuando comencé, pero mis pares generalmente lo cambiaban a "i".

Answer 12

Empecé a usar nombres de variables de bucle relevantes para el contexto mezclados con húngaro .

Al pasar por las filas, iRow . Al pasar por las columnas, iCol . Al recorrer autos, iCar . Entiendes la idea.

Answer 13

La primera regla es que la longitud del nombre de la variable debe coincidir con el alcance de la variable. La segunda regla es que los nombres significativos hacen que los errores sean más superficiales. La tercera regla es que si desea agregar un comentario a un nombre de variable, debe elegir el nombre de variable incorrecto. La regla final es hacer lo que hacen sus compañeros de equipo, siempre que no contrarreste las reglas anteriores.

Answer 14

Mi convención favorita para pasar por encima de un conjunto tipo matriz es usar x + y como se usan en coordenadas cartesianas:

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

Answer 15

Uso i , j , k (o r & c para bucle de fila-columna). Si necesita más de tres variables de bucle en un método , probablemente el método sea demasiado largo y complejo y su código probablemente se beneficie al dividir el método en más métodos y darles un nombre adecuado .

Answer 16

para cálculos numéricos, matlab y similares, no use i, j

estas son constantes reservadas, pero matlab no se quejará.

Mis favoritos personales son

index first, second counter count

Answer 17

Elija lo que elija, use el mismo índice de manera coherente en su código siempre que tenga el mismo significado. Por ejemplo, para recorrer un conjunto, puede usar i , jj , kappa , lo que sea, pero siempre hágalo de la misma manera en todas partes:

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

La mejor práctica es hacer que esta parte del ciclo se vea igual a lo largo de su código (lo que incluye consistentemente usar count como el límite), de modo que se convierta en un modismo que pueda omitir mentalmente para enfocarse en la esencia del código, el cuerpo del bucle

De manera similar, si está caminando a través de una matriz de píxeles en 2D, por ejemplo, puede escribir

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

Solo hazlo de la misma manera en cada lugar donde escribas este tipo de ciclo.

Desea que sus lectores puedan ignorar la configuración aburrida y ver la brillantez de lo que está haciendo en el ciclo real.

Answer 18

El Código Completo de Steve McConnell tiene, como de costumbre, algunos excelentes consejos al respecto. Las páginas relevantes (en la primera edición de todos modos) son 340 y 341. Definitivamente aconsejar a cualquiera que esté interesado en mejorar su codificación de bucle para darle un vistazo. McConnell recomienda nombres de contador de bucle significativos, pero la gente debería leer lo que dice él mismo en lugar de confiar en mi débil resumen.

Answer 19

Usualmente uso:

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

Answer 20

Para los enteros uso el índice int, a menos que esté anidado, entonces uso un sufijo de índice sobre lo que se itera como int groupIndex e int userIndex.

Answer 21

Hace tiempo que uso el esquema de nombres i / j / k. Pero recientemente comencé a adaptar un método de nombres más consecuente.

Ya nombré todas mis variables por su significado, así que ¿por qué no nombrar la variable de ciclo de la misma manera determinista?

Como solicité algunos ejemplos:

Si necesita pasar por una colección de elementos.

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

Pero trato de evitar los bucles normales, porque tiendo a querer el elemento real en la lista y lo uso, no la posición real en la lista. así que en lugar de comenzar el bloqueo con a:

Item currentItem = list[currentItemIndex];

Intento utilizar el constructo foreach del lenguaje. que transforma el.

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

dentro

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

Lo que hace que sea más fácil de leer porque solo se expresa el significado real del código (procesa los elementos en la lista) y no la forma en que queremos procesar los elementos (mantener un índice del elemento actual en aumentarlo hasta que alcance la longitud de la lista y, por lo tanto, significa el final de la colección de elementos).

La única vez que todavía uso variables de una letra es cuando estoy haciendo un bucle a través de las dimensiones. Pero luego usaré x, y, a veces z.

Answer 22

En Python, uso i, j y k si solo estoy contando los tiempos. Utilizo x, y y z si el recuento de iteraciones se usa como índice. Sin embargo, si estoy generando una serie de argumentos, usaré un nombre significativo.

Answer 23

Siempre uso un nombre significativo a menos que sea un ciclo de un solo nivel y la variable no tenga otro significado que no sea "la cantidad de veces que he pasado por este ciclo", en cuyo caso uso i .

Al usar nombres significativos:

• el código es más comprensible para los colegas que leen su código,
• es más fácil encontrar errores en la lógica de bucle, y
• las búsquedas de texto para el nombre de la variable para devolver piezas relevantes de código que operan en los mismos datos son más confiables.

Ejemplo: detectar el error

Puede ser complicado encontrar el error en este bucle anidado usando letras simples:

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

mientras que es más fácil cuando se usan nombres significativos:

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

¿Por qué row_num ? - alternativas rechazadas

En respuesta a algunas otras respuestas y comentarios, estas son algunas sugerencias alternativas para usar row_num y col_num y por qué elegí no usarlas:

• r y c : Esto es ligeramente mejor que i y j . Solo consideraría usarlos si el estándar de mi organización fuera que las variables de una sola letra fueran números enteros, y que siempre fuera la primera letra del nombre descriptivo equivalente. El sistema se caería si tuviera dos variables en la función cuyo nombre comenzaba con "r", y la legibilidad sufriría incluso si aparecían en el código otros objetos que comenzaran con "r".
• rr y cc : Esto me parece extraño, pero no estoy acostumbrado a un estilo de bucle doble variable. Si fuera el estándar en mi organización, entonces me imagino que sería un poco mejor que r y c .
• row and col : A primera vista, esto parece más sucinto que row_num y col_num , y también como descriptivo. Sin embargo, esperaría que los nombres simples como "fila" y "columna" hagan referencia a estructuras, objetos o indicadores de estos. Si row podría significar la estructura de la fila en sí, o un número de fila, se producirá confusión.
• iRow e iCol : Esto transmite información adicional, ya que puedo decir que es un contador de bucles mientras Row y Col te dicen lo que está contando. Sin embargo, prefiero poder leer el código casi en inglés:
  • row_num < MAX_COLS lee como "el número de fila es menor que el máximo imum (número de) columna s ";
  • iRow < MAX_COLS en el mejor de los casos se lee como "el contador de bucle entero para la fila es menor que el máximo (número de) columna s ".
  • Puede ser algo personal, pero prefiero la primera lectura.

Una alternativa al row_num que aceptaría es row_idx : la palabra "index" se refiere únicamente a una posición de matriz, a menos que el dominio de la aplicación esté en el diseño del motor de la base de datos, mercados financieros o similar.

Mi ejemplo anterior es tan pequeño como podría hacerlo, y como tal, algunas personas podrían no ver el sentido de nombrar las variables descriptivamente ya que pueden mantener toda la función en su cabeza de una vez. En el código real, sin embargo, las funciones serían más grandes y la lógica más compleja, por lo que los nombres decentes se vuelven más importantes para ayudar a la legibilidad y para evitar errores.

En resumen, mi objetivo con todos los nombres variables (no solo los bucles) es ser completamente inequívoco . Si alguien lee alguna parte de mi código y no puede determinar para qué es una variable inmediatamente, entonces he fallado.

Answer 24

Ejemplos: . . En Java

Bucles no iterativos:

Bucles no anidados:. . . El índice es un valor.

. . . Usar i , como lo harías en Algebra, es la práctica más común . . .

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

    // LOOP_BODY
}

Bucles anidados:. . . La diferenciación de índices se presta a la comprensión.

. . . usando un sufijo descriptivo . . .

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

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

        // LOOP_BODY
    }
}

foreach Loops:. . . Un Object necesita un nombre.

. . . usando un nombre descriptivo. . .

for (Object something : somethings) {

    // LOOP_BODY
}

Iterative Loops:

for Bucles:. . . Iteradores hacen referencia a objetos. Un iterador no es ninguno de los dos; un índice, ni un índice.

. . . iter abrevia un propósito Iteradores . . .

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

    Object object = iter.next();

    // LOOP_BODY
}

while Loops:. . . Limite el alcance del iterador.

. . . comentando el propósito de los bucles . . .

/* LOOP_DESCRIPTION */ {

    Iterator iter = collection.iterator();

    while (iter.hasNext()) {

        // LOOP_BODY
    }
}

Este último ejemplo se lee mal sin comentarios, lo que los alienta. Es quizás detallado, pero útil en el alcance que limita los bucles en C.

Answer 25

también uso la convención de doble letra. ii, jj, kk. puedes grep y no tener un montón de partidos no deseados.

Creo que usar esas letras, aunque estén duplicadas, es la mejor manera de hacerlo. es una convención familiar, incluso con el doble.

hay mucho que decir para seguir con las convenciones. hace que las cosas sean mucho más legibles.

Answer 26

1) Para bucles pequeños de estilo antiguo normales - i, j, k - Si necesita más de 3 bucles anidados de nivel, esto significa que el algoritmo es muy específico y complejo, o bien debería considerar la refacturación del código.

Ejemplo de Java:

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

2) Para el nuevo estilo de bucles java como for(Element element: ElementsList) Lista de for(Element element: ElementsList) , es mejor usar el nombre meanigful normal

Ejemplo de Java:

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

3) Si es posible con el idioma que usas, convierte el ciclo para usar el iterador

Ejemplo de Java Iterator: haga clic aquí

Answer 27

Mi experiencia es que la mayoría de las personas usa letras simples, por ejemplo: i , j , k , ... o x , y , o r , c (para fila / columna) o w , h (para ancho / alto), etc.

Pero aprendí una gran alternativa hace mucho tiempo, y la he usado desde entonces: variables de doble letra.

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

En caso de que el beneficio no sea inmediatamente obvio: al buscar en el código una sola letra encontrará muchas cosas que no son lo que está buscando. La letra i aparece con bastante frecuencia en el código donde no es la variable que está buscando.

Answer 28

Siempre trate de nombrar la variable algo significativo y en contexto.

Si no puede decidir, use "índice", aunque solo sea para que otra persona (¡quizás usted!) Pueda hacer clic en él más fácilmente para refactorizar más tarde.

Paul Stephenson Vea esta respuesta para un ejemplo.