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

Question

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

например

private String var1, var2, var3

вместо:

private String var1;
private String var2;
private String var3;

Answer 1

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

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

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

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

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

Answer 2

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

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

Answer 3

В С++:

int * i, j;

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

Кроме того, если они расположены в одной строке, каждый из них упрощает добавление комментариев позже.

Answer 4

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

int* var1, var2, var3;

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

int* var1;
int var2;
int var3;

делая только var1 указателем.

Answer 5

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

Answer 6

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

Answer 7

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

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

//better
int counter, 
    childCounter, 
    percentComplete;

Answer 8

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

плавающее значение fMin, fMax;

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

интервал iBalance, iColor;

Answer 9

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

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

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

Answer 10

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

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

Answer 11

А как насчет таких случаев, как:

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

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

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

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

Answer 12

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

Answer 13

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

Answer 14

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

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

Answer 15

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

интервал с, т;// координаты текстуры

ИМХО повышает читаемость кода как за счет сокращения кода, так и за счет четкого указания того, что эти две переменные принадлежат друг другу (конечно, некоторые будут выступать за использование одной переменной класса точки в этом случае).

Answer 16

пытаясь задать этот вопрос 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;
}