Qu'est ce qu'une variable idéale convention d'affectation de noms pour les variables de boucle?

Question

Si vous écrivez une simple petite boucle, ce qui devrait vous nom le compteur?

Fournir de l'exemple de la boucle!

Answer 1

J'ai toujours utiliser un nom significatif , sauf si c'est un seul niveau de la boucle et la variable n'a pas de sens autre que "le nombre de fois où j'ai été par le biais de cette boucle", auquel cas je utiliser i.

Lors de l'utilisation des noms significatifs:

• le code est plus compréhensible pour les collègues de la lecture de votre code,
• il est plus facile de trouver des bugs dans la boucle de la logique, et
• les recherches de texte pour le nom de la variable de retour pertinents morceaux de code d'exploitation sur les mêmes données sont plus fiables.

Exemple - spot le bug

Il peut être difficile de trouver le bug dans cette boucle imbriquée à l'aide d'une seule lettre:

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

considérant qu'il est plus facile lors de l'utilisation des noms significatifs:

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

Pourquoi row_num? - a rejeté les alternatives

En réponse à certaines autres réponses et commentaires, voici quelques suggestions alternatives à l'utilisation d' row_num et col_num et pourquoi j'ai choisi de ne pas les utiliser:

• r et c: C'est légèrement mieux qu' i et j. Je tiens seulement à considérer si mon standard de l'organisation ont pour seule lettre variables qui doivent être des entiers, et aussi toujours être la première lettre de l'équivalent nom descriptif. Le système serait de tomber si j'avais deux variables dans la fonction dont le nom commence par "r", et la lisibilité aurait à souffrir, même si d'autres objets commençant par "r" apparaît n'importe où dans le code.
• rr et cc: Cela fait un peu bizarre pour moi, mais je n'ai pas l'habitude de faire un double-lettre variable de boucle de style. Si c'était la norme dans mon organisation alors j'imagine que ce serait un peu mieux que r et c.
• row et col: À première vue, cela semble plus succincte que row_num et col_num, et tout comme descriptif. Toutefois, je m'attends à nu des noms comme "lignes" et "colonnes" pour se référer à des structures, des objets ou des pointeurs vers ces. Si row pourrait signifier soit la ligne de la structure elle-même, ou un numéro de ligne, puis la confusion en résulte.
• iRow et iCol: Cela transmet des informations supplémentaires, depuis i peut dire que c'est un compteur de boucle, alors que Row et Col vous dire ce qu'il compte. Cependant, je préfère être capable de lire le code presque en anglais:
  • row_num < MAX_COLS lit que "la ligne number est moins que le maxm (nombre de) columns";
  • iRow < MAX_COLS , au mieux, se lit comme "l' entier compteur de boucle de la ligne est moins que le maxm (nombre de) columns".
  • Il peut être une chose de personnel, mais je préfère la première lecture.

Une alternative à l' row_num j'accepterais est - row_idx: le mot "index" uniquement fait référence à une position de tableau, à moins que le domaine de l'application est dans la base de données de conception du moteur, des marchés financiers ou similaire.

Mon exemple ci-dessus est aussi petit que je pouvais le faire, et, comme telle, certaines personnes pourraient ne pas voir le point de nommer les variables de façon descriptive, car ils peuvent contenir l'ensemble de la fonction dans leur tête d'un seul coup. Dans le code réel, cependant, les fonctions seraient plus grandes, et la logique plus complexe, de sorte décent noms de devenir de plus en plus important à l'aide de lisibilité et pour éviter des bugs.

En résumé, mon but avec toutes les variables de nommage (et pas seulement les boucles) est sans ambiguïté. Si quelqu'un lit toute la partie de mon code et ne peux pas savoir ce qu'est une variable est pour tout de suite, je n'ai pas réussi.

Answer 2

1) Pour le mode normal de style ancien de petites boucles - i, j, k - Si vous avez besoin de plus de 3 niveaux de boucles imbriquées, cela signifie que l'algorithme est très complexe et spécifique, vous devriez envisager de refactoriser le code.

Java Exemple:

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

2) Pour le nouveau style java boucles comme for(Element element: ElementsList) il est préférable d'utiliser la normale meanigful nom

Java Exemple:

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

3) Si cela est possible avec le langage que vous utilisez, convertir la boucle à utiliser l'itérateur

Java Itérateur Exemple: cliquez ici

Answer 3

mon expérience est que la plupart des gens utilisent des lettres simples, par exemple: i, j, k, ... ou x, y, ou r, c (pour la ligne/colonne) ou w, h ((largeur/hauteur) , etc.

mais j'ai appris une excellente alternative il y a longtemps, et l'ont utilisé depuis: double lettre variables.

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

dans le cas où l'avantage n'est pas immédiatement évidente: la recherche par le biais de code pour une seule lettre trouverez beaucoup de choses qui ne sont pas ce que vous cherchez. la lettre i se produit assez souvent dans le code où il n'est pas la variable que vous cherchez.

Answer 4

Exemples: . . . En Java

Non Itératif Boucles:

Non-Boucles Imbriquées: . . . L'Indice est une valeur.

. . . à l'aide de i, comme vous le feriez dans l'Algèbre, est le plus commun de pratiquer . . .

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

    // LOOP_BODY
}

Boucles Imbriquées: . . . La différenciation des Indices prête à la compréhension.

. . . l'aide d'un descriptif de suffixe . . .

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

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

        // LOOP_BODY
    }
}

foreach Boucles: . . . Un Object besoin d'un nom.

. . . à l'aide d'un nom descriptif . . .

for (Object something : somethings) {

    // LOOP_BODY
}

Itératif Boucles:

for Boucles: . . . Les itérateurs Objets de référence. Un Itérateur, il n'est ni; un Index, ni un Indice.

. . . iter abreviates un Itérateurs but . . .

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

    Object object = iter.next();

    // LOOP_BODY
}

while Boucles: . . . Limiter le champ d'application de l'Itérateur.

. . . commentant les boucles de but . . .

/* LOOP_DESCRIPTION */ {

    Iterator iter = collection.iterator();

    while (iter.hasNext()) {

        // LOOP_BODY
    }
}

Ce dernier exemple lit mal sans les commentaires, les encourageant à eux. Il est bavard, peut-être, mais utile dans le champ d'application de limiter les boucles en C.

Answer 5

Essayez toujours de nom de la variable quelque chose de significatif, et dans le contexte.

Si vous ne pouvez pas décider, puis utiliser "index", ne serait-ce que quelqu'un d'autre (peut-être vous!) peut plus facilement cliquer sur elle pour la refactorisation plus tard.

Paul Stephenson Voir cette réponse pour un exemple.