Почему вы не объявляете несколько переменных одного типа в одной строке?

Почему плохая практика объявлять переменные в одной строке?

например

private String var1, var2, var3

вместо: 

private String var1;
private String var2;
private String var3;
12
conventions language-agnostic refactoring

16 ответов

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

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

это похоже на то, что происходит, когда у вас есть

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

конечно, этот пример намного хуже вашего.

8

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

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

21

В C++ :

int * i, j;

i имеет тип int *, j имеет тип int. Это различие слишком легко упустить.

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

18

В C / C++ у вас также есть проблема, что*, используемый для указания типа указателя, применяется только к непосредственно следующему идентификатору. Поэтому довольно распространенной ошибкой неопытных разработчиков является написание

int* var1, var2, var3;

и ожидая, что все три переменные будут иметь тип "int pointer", тогда как для компилятора это читается как

int* var1;
int var2;
int var3;

создание только var1 указателя.

9

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

6

потому что на некоторых языках var2 и var3 в вашем примере будут не быть строками, они будут вариантов (нетипизированный).

5

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

float fMin, fMax;

однако я держусь подальше, когда переменные не связаны, например

int iBalance, iColor;

4

почему это плохая практика? Я не думаю, что это так, пока ваш код все еще читается.

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

//better
int counter, 
    childCounter, 
    percentComplete;
4

актуальность.

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

Если две (или более) переменные тесно связаны функцией, а не типом переменной, то, возможно, они могут быть объявлены вместе. т. е. только если для читателя вашей программы имеет смысл видеть две переменные вместе, они действительно должны быть помещены вместе

4

вот мои причины:

  • читаемость, легче обнаружить, если вы знаете, что есть только один на каждой строке
  • контроль версий, меньше внутристрочных изменений, больше однострочных дополнений, изменений или удалений, легче объединяться из одной ветви в другую
3

Как насчет случая, например:

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

это тоже считается плохой практикой? Я бы счел, что все в порядке, поскольку это противоречит некоторым из ранее сделанных пунктов:

  • они все определенно будут одного типа (в моем статически типизированном Java-мире)
  • комментарии могут быть добавлены для каждого
  • если вам нужно изменить тип на один, вам, вероятно, придется сделать это для всех, и все четыре можно сделать за одно изменение

Итак, в Примере (хотя и вонючий код), есть ли причины, по которым вы бы этого не сделали?

2

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

0
  1. чтобы быть более очевидным для вас при использовании инструментов управления версиями (охватываемых Michel)
  2. чтобы быть более понятным для вас, когда у вас есть простое переполнение/недополнение или ошибка компиляции, и ваши глаза не понимаю
  3. для защиты противоположного (т. е. многопеременное однострочное объявление) имеет меньше плюсов ("текстовая вертикальная видимость кода" является одноэлементным)
0

Это плохая практика, в основном, когда вы можете и хотите инициализировать переменные на торможение. Пример, где это может быть не так плохо:

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

обычно это так, для контроля версий и комментирования причин, обсуждаемых другими, и я бы применил это в 95% всех случаев. однако есть обстоятельства, когда это имеет смысл, например, если я кодирую графику, и я хочу, чтобы несколько переменных представляли координаты текстуры (всегда ссылающиеся на соглашение как s и t), то объявление их как

int s, t; / / координаты текстуры

IMHO увеличивает считываемость кода и путем сокращать код и сделав явным, что эти две переменные принадлежат друг другу (Конечно, некоторые будут утверждать, что в этом случае используется одна переменная точечного класса).

0

при попытке этого вопроса https://www.interviewbit.com/problems/remove-element-from-array/

метод 1 дает превышенный предел памяти для этого кода:

Тип 1:

int i,j;

Тип 2:

int i;
int j;

тип 1: дает превышенный предел памяти

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

в то время как тип 2 отлично работает

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