Всегда ли определение каждой переменной в верхней части - лучший подход?

Question

Я слышал, что это хорошая техника для определения ваших переменных в верхней части функции, так что вы не столкнетесь с проблемами подъема переменных. Это:

// Beginning of file

function something(){
    var a, b, c = 1, d, e;
    // Do something
}

// End of file

является хорошим примером (за исключением, конечно, неправильных имен переменных).

Мой вопрос: всегда ли это лучший подход? Что делать, если вы работаете с большим количеством переменных? Должны ли они на самом деле просто быть на одной линии?

Answer 1

Я бы настоятельно рекомендовал прочитать Code Complete 2 от Стива Макконнелла . Его аргумент в том, что вы не должны ни объявлять все свои переменные в одну строку , ни объявлять их все в начале процедуры. Так что не делайте этого:

function foo() {
    var a,
        b,
        c,
        d;

     /**
      * 20 lines that use a and b
      */

     /**
      * 10 lines that use c and d
      */
}

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

function foo() {
    var a,
        b;

     /**
      * 20 lines that use a and b
      */

     var c,
         d;

     /**
      * 10 lines that use c and d
      */
}

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

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

Answer 2

«Должны ли они на самом деле просто быть на одной линии?»

Я так не думаю.

Вот как бы я написал это (игнорируя имена):

function something(){
    var a,
        b,
        c = 1,
        d,
        e;
    // Do something
}

Это только выглядит глупо в приведенном выше , потому что 1) имена отстой 2) переменные не присваиваются в «объявлении» - большая часть кода может быть написана с неизменяемыми (назначенными один раз) переменными и Я нахожу это для упрощения кода. Я использую это по нескольким причинам, включая ясность и устойчивость к изменениям форматирования (то есть я могу изменять начальные значения, добавлять / удалять объявления и т. Д., Не разбираясь с форматированием других строк).

«Всегда ли лучше определять каждую переменную сверху?»

Я так не думаю.

Например, вот как я пишу циклы:

for (var i = 0; i < x; i++) {
  var elm = elms[i];
  ...
}

И некоторые люди скажут: «НО ВАР ПОДНИМАЕТСЯ НА ВЕРХНУЮ ФУНКЦИЮ!» или «ПЕРЕМЕННАЯ ФУНКЦИОНАЛЬНАЯ!». Ну, действительно. Однако это позволяет мне визуально видеть, что это ошибка, даже если движок JavaScript не поможет:

for (var i = 0; i < x; i++) {
  var elm = elms[i];
  ...
}
...
// valid JS but since I consider this construct *invalid*
// I know this is a *bug* in my code
alert(elm);

Насколько я назначаю переменным, пойманным в замыканиях: это зависит. Если переменная используется только в одном замыкании, я обычно помещаю ее прямо выше. Это позволяет мне знать, что следует использовать только в этом закрытии . Если переменная является общей (например, self), я помещаю ее выше всех применимых замыканий - как правило, в «разделе объявления переменной» функции. Это позволяет мне знать, что у него есть «область действия всей функции» (читай: вероятно, будет использоваться в нескольких привязках).

Чтобы решить вопрос «для каждого закрытия» - просто изучите язык. Хранение переменных «объявления» вблизи закрытия не влияет на это в любом случае. Если конструкция не понята, действительно не имеет значения как написан код.

Я использую эти подходы к /, потому что:

1. Иметь последовательный, легко сканируемый код.
2. Напишите код, который сообщает мне, когда он неправильный .
3. Я предпочитаю код, который можно изменять без изменения структуры.
4. Самодокументированный код означает меньше комментариев.
5. Мне нравится "читать по вертикали"

Удачного кодирования.

Answer 3

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

Но поскольку JavaScript не имеет области видимости блока, разумнее объявить все переменные функции в верхней части функции.Таким образом, вы не обманываете себя или других людей в отношении области действия переменной.

РЕДАКТИРОВАТЬ: Многие люди работают с несколькими языками одновременно.Часто JavaScript является единственным из них без области видимости блока.

Answer 4

Это вопрос стиля. Не вопрос функциональности.

Парсер JavaScript примет этот код

function() {
   dostuff();
   var i = 4;
}

и превратить его в:

function() {
   var i;
   dostuff();
   i = 4;
}

Что касается вопроса стиля. Нет, спасибо, я думал, что мы оставили это с ANSI C.

То, что вы хотите сделать, это объявить функции в верхней части их "области видимости"

Если "область видимости" переменной - это целая функция, тогда объявите их сверху. Если «область действия» является подмножеством функции, объявите их в начале подмножества.

трактует «область» как логическую область, а не область функции.

Это должно обеспечить максимальную читаемость.

Answer 5

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

var func = function(arr) {
    for (var i = 0, len = arr.length; i < len; i++) {
        // array processing here
    }
}

Почти во всех других случаях, хотя по причинам подъема я помещу ВСЕ переменные вверху,Если вы обнаружите, что в верхней части вашей функции слишком много переменных, это может указывать на то, что ваш метод выполняет слишком много работы, и вам следует рассмотреть возможность его извлечения в какой-то вспомогательный метод.Это позволит вам организовать ваши переменные на основе функциональности.

Answer 6

Рискну сказать, что в более старых структурах (таких как дни C \ C ++) было важно инициализировать ваши переменные и присвоить им начальное значение. Но с тем, как идут дела, я обнаружил, что объявление их «при необходимости» является действительной реализацией. Если только область действия не играет роли (например, вам нужна переменная a не только в этой функции, но и в других функциях), я бы объявил на ходу.

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

Однако я могу быть совершенно неправ. В любом случае, JavaScript позволит вам объявлять переменные любым способом, который вы считаете наиболее простым для чтения.