Pourquoi ne déclarez-vous pas plusieurs variables du même type sur la même ligne?

StackOverflow https://stackoverflow.com/questions/100633

Question

Pourquoi est-ce une mauvaise pratique de déclarer des variables sur une ligne?

par exemple 

private String var1, var2, var3

au lieu de: 

private String var1;
private String var2;
private String var3;
Était-ce utile?

La solution

Je pense qu'il y a diverses raisons, mais elles se résument toutes au fait que la première est un peu moins lisible et plus sujette à l'échec car une seule ligne fait plus d'une chose.

Et tout cela sans aucun gain réel, et ne me dites pas que vous trouvez deux lignes d’espace économisé est un réel gain.

C’est une chose semblable à ce qui se passe lorsque vous avez 

if ((foo = some_function()) == 0) {
    //do something
}

Bien sûr, cet exemple est bien pire que le vôtre.

Autres conseils

À mon avis, l'objectif principal de chaque variable sur une ligne distincte est de faciliter le travail des outils de contrôle de version.

Si plusieurs variables se trouvent sur la même ligne, vous risquez d'avoir des conflits pour des modifications sans rapport avec d'autres développeurs.

En C ++: 

int * i, j;

i est de type int *, j est de type int. La distinction est trop facilement manquée.

En plus de les avoir sur une seule ligne, il est plus facile d'ajouter des commentaires plus tard

En C / C ++, vous avez également le problème que le * utilisé pour indiquer un type de pointeur ne s'applique qu'à l'identificateur suivant. Donc, une erreur plutôt commune des développeurs inexpérimentés est d’écrire 

int* var1, var2, var3;

et s’attendant à ce que les trois variables soient du type 'int pointer', alors que pour le compilateur, cela se lit comme 

int* var1;
int var2;
int var3;

ne faisant que var1 un pointeur.

Avec des lignes séparées, vous avez la possibilité d'ajouter un commentaire sur chaque ligne décrivant l'utilisation de la variable (si le nom ne l'indique pas).

Étant donné que dans certaines langues, var2 et var3 dans votre exemple ne seraient pas des chaînes, elles seraient des variantes (non typées).

Pourquoi est-ce une mauvaise pratique? Je ne pense pas que ce soit le cas, tant que votre code est toujours lisible. 

//not much use
int i, j, k;

//better
int counter, 
    childCounter, 
    percentComplete;

Pour être honnête, je ne suis pas contre. Je pense qu'il est parfaitement possible de regrouper des variables similaires sur la même ligne, par exemple

.

float fMin, fMax;

Cependant, je suis clair lorsque les variables ne sont pas liées, par exemple.

int iBalance, iColor;

Pertinence.

Le fait que deux variables soient du type String ne signifie pas qu’elles sont étroitement liées.

Si les deux variables (ou plus) sont étroitement liées par fonction, plutôt que par type de variable, elles pourraient peut-être être déclarées ensemble. c'est-à-dire que si un lecteur de votre programme a intérêt à voir les deux variables ensemble si elles sont réellement placées ensemble

Voici mes raisons:

  • Lisibilité, plus facile à repérer si vous savez qu'il n'y en a qu'une sur chaque ligne
  • Contrôle des versions, moins de modifications intra-lignes, plus d'ajouts, de modifications ou de suppressions sur une seule ligne, fusion plus facile d'une branche à une autre

Qu'en est-il des cas tels que: 

public static final int NORTH = 0,
                        EAST = 1,
                        SOUTH = 2,
                        WEST = 3;

Est-ce également considéré comme une mauvaise pratique? Je considérerais que cela va bien car il contredit certains des points déjà soulevés:

  • ils seraient certainement tous du même type (dans mon monde Java statiquement typé)
  • des commentaires peuvent être ajoutés pour chaque
  • si vous devez changer le type pour un, vous devez probablement le faire pour tous, et les quatre peuvent être faits en une seule modification

Donc, dans un exemple (bien que malodorant), y a-t-il des raisons pour lesquelles vous ne le feriez pas?

Je suis d’accord avec edg, et aussi parce qu’il est plus lisible et plus facile pour la maintenance d’avoir chaque variable sur une ligne distincte. Vous voyez immédiatement le type, la portée et les autres modificateurs. Lorsque vous modifiez un modificateur, il s’applique uniquement à la variable de votre choix, ce qui évite les erreurs.

  1. pour être plus clair lorsque vous utilisez les outils de contrôle de version (couvert par Michel)
  2. pour être plus lisible lorsque vous avez le plus simple dépassement de capacité / erreur de compilation ou si vous avez une erreur de compilation et que vos yeux ne parviennent pas à signaler l'évidence
  3. pour défendre le contraire (c'est-à-dire une déclaration multiligne à plusieurs variables) a moins d'avantages ("visibilité textuelle verticale du code" étant un singleton)

C’est une mauvaise pratique surtout lorsque vous pouvez et souhaitez initialiser des variables sur la décélération. Voici un exemple où cela pourrait ne pas être aussi grave: 

string a,b;
if (Foo())
{
  a = "Something";
  b = "Something else";
}
else
{
  a = "Some other thing";
  b = "Out of examples";
}

En général, oui, pour les raisons de contrôle de version et de commentaire discutées par d’autres, et je l’appliquerais dans 95% des cas. Cependant, il y a des cas où cela a du sens, par exemple si je code des graphiques et que je veux quelques variables pour représenter les coordonnées de texture (toujours référencées par convention comme s et t), puis les déclarer comme

.

int s, t; // coordonnées de texture

IMHO améliore la lisibilité du code, à la fois en le raccourcissant et en expliquant que ces deux variables appartiennent ensemble (bien sûr, certains préconiseraient l’utilisation d’une variable de classe à point unique dans ce cas).

en essayant cette question https://www.interviewbit.com/ problèmes / remove-element-from-array /

La méthode 1 donne la limite de mémoire dépassée pour ce code:

Type 1: 

int i,j;

Type 2: 

int i;
int j;

type 1: limite de mémoire dépassée 

int removeElement  (int* A, int n1, int B) 
{
    int k=0, i;
    for(i=0;i<n1;i++)
        if(A[i]!=B)
        {
            A[k]=A[i];
            k++;
        }    
    return k;
}

Alors que le type 2 fonctionne parfaitement bien 

int removeElement  (int* A, int n1, int B) 
{
    int k=0;
    int i;
    for(i=0;i<n1;i++)
        if(A[i]!=B)
        {
            A[k]=A[i];
            k++;
        }    
    return k;
}
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top