Концепция единства по связанность может применяться не только к объектам / модулям / функциям. Также он может служить в этой ситуации:

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

Из Coupling:

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

Так что выберите первый.

Я считаю, что до того, как мы начали использовать ES6, подход с одним объявлением var не был ни хорошим, ни плохим (в случае, если у вас есть линтеры и 'use strict'. Это действительно было вкусовое предпочтение. Но теперь все изменилось для меня. Это мои мысли в пользу многострочного объявления:

1. Теперь у нас есть два новых вида переменных, и var устарели. Хорошая практика - использовать const везде, пока let вам действительно не понадобится. Поэтому довольно часто ваш код будет содержать объявления переменных с присваиванием в середине кода, и из-за области видимости блока вы довольно часто будете перемещать переменные между блоками в случае небольших изменений. Я думаю, что это удобнее делать с многострочными объявлениями.

2. Синтаксис ES6 стал более разнообразным, появились деструкторы, строки шаблонов, стрелочные функции и необязательные присваивания. Когда вы интенсивно используете все эти функции с объявлениями одной переменной, это ухудшает удобочитаемость.

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

    var categories = ko.observableArray(),
        keywordFilter = ko.observableArray(),
        omniFilter = ko.observable('').extend({ throttle: 300 }),
        filteredCategories = ko.computed(function () {
            var underlyingArray = categories();
            return ko.utils.arrayFilter(underlyingArray, function (n) {
                return n.FilteredSportCount() > 0;
            });
        }),
        favoriteSports = ko.computed(function () {
            var sports = ko.observableArray();
            ko.utils.arrayForEach(categories(), function (c) {
                ko.utils.arrayForEach(c.Sports(), function (a) {
                    if (a.IsFavorite()) {
                        sports.push(a);
                    }
                });
            });
            return sports;
        }),
        toggleFavorite = function (sport, userId) {
            var isFavorite = sport.IsFavorite();

            var url = setfavouritesurl;

            var data = {
                userId: userId,
                sportId: sport.Id(),
                isFavourite: !isFavorite
            };

            var callback = function () {
                sport.IsFavorite(!isFavorite);
            };

            jQuery.support.cors = true;
            jQuery.ajax({
                url: url,
                type: "GET",
                data: data,
                success: callback
            });
        },
        hasfavoriteSports = ko.computed(function () {
            var result = false;
            ko.utils.arrayForEach(categories(), function (c) {
                ko.utils.arrayForEach(c.Sports(), function (a) {
                    if (a.IsFavorite()) {
                        result = true;
                    }
                });
            });
            return result;
        });

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

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

Для несвязанных переменных

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

const unrelatedVar1 = 1;
const unrelatedVar1 = 2;
const unrelatedVar1 = 3;

Для сопутствующих вещей (утилита)

Если я создаю новые переменные, я объявляю их блоком - это служит намеком на то, что атрибуты принадлежат друг другу.

const
  x = 1,
  y = 2,
  z = 3
;

// or
const x=1, y=2, z=3;

// or if I'm going to pass these params to other functions/methods
const someCoordinate = {
  x = 1,
  y = 2,
  z = 3
};

это, как мне кажется, больше соответствует деструктуризации:

const {x,y,z} = someCoordinate;

где было бы неудобно делать что-то вроде (Я бы этого не сделал)

const x = someCoordiante.x;
const y = someCoordiante.y;
const z = someCoordiante.z;

Для сопутствующих вещей (строительство)

Если с помощью одного и того же конструктора создается несколько переменных, я также часто группирую их вместе; Я лично нахожу это более читаемым

Вместо чего-то вроде (Обычно я так не делаю)

const stooge1 = Person("moe");
const stooge2 = Person("curly");
const stooge3 = Person("larry");

Я обычно делаю следующее:

const [stooge1, stooge2, stooge3] = ["moe", "curly", "larry"].map(Person);

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

Я согласен с комментариями других людей о use-strict