正如每个人都说的，这主要是偏好和可读性，但我将在这个帖子上发表评论，因为我没有看到其他人分享这样的想法

我认为这个问题的答案很大程度上取决于你所设置的变量以及它们之间的关系。我尝试着基于我所创造的变量是否相关而保持一致;我的偏好大致是这样的:

对于不相关的变量

我把它们排成一行，这样以后可以很容易地移动它们;我个人从来不会以其他方式声明不相关的项目:

const unrelatedVar1 = 1;
const unrelatedVar2 = 2;
const unrelatedVar3 = 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);

我说通常是因为如果输入参数足够长，这会变得不可读，我会把它们分开。

我同意其他人关于严格使用的评论

对于组织来说，每个作用域使用一个var语句是很常见的。所有“作用域”都遵循类似的模式，使代码更具可读性。此外，引擎会把它们都“吊”到顶部。因此，将声明放在一起可以更紧密地模拟实际发生的情况。

是一个很好的特性。没有理由逃避。随着技术的发展，我们也必须自我进化。这个特性在Perl等一些语言中已经存在很长时间了。例如构建WebGL网格，新的javascript样式

   //initialize vertices with some calculated points
   [verts[ix],     verts[iy],     verts[iz]]     = ps[0];
   [verts[ix + 3], verts[iy + 3], verts[iz + 3]] = ps[1];
   [verts[ix + 6], verts[iy + 6], verts[iz + 6]] = ps[2];
   //initializing normals with cross products
   [norms[ix],     norms[iy],     norms[iz]]     = cr;
   [norms[ix + 3], norms[iy + 3], norms[iz + 3]] = cr;
   [norms[ix + 6], norms[iy + 6], norms[iz + 6]] = cr;

事实上，老式的代码更难调试，到目前为止也更难理解和发现任何bug。这个样本过于简化了。大量重复的例程阻碍了真正的逻辑，使代码看起来像某种魔法。和上面一样，不过是古风:

      //initialize vertices with some calculated points
      verts[ix]     =  ps[0][0];
      verts[iy]     =  ps[0][1];
      verts[iz]     =  ps[0][2];
      verts[ix + 3] =  ps[1][0];
      verts[iy + 3] =  ps[1][1];
      verts[iz + 3] =  ps[1][2];
      verts[ix + 6] =  ps[2][0];
      verts[iy + 6] =  ps[2][1];
      verts[iz + 6] =  ps[2][2];
      //initializing normals with cross products
      norms[ix]     =  cr[0];
      norms[iy]     =  cr[1];
      norms[iz]     =  cr[2];
      norms[ix + 3] =  cr[0];
      norms[iy + 3] =  cr[1];
      norms[iz + 3] =  cr[2];
      norms[ix + 6] =  cr[0];
      norms[iy + 6] =  cr[1];
      norms[iz + 6] =  cr[2];

注意，在迁移新样式的代码时，我不仅大量删除了大块的例程代码。我很容易就发现了那些逃避了大量代码审查的不一致之处，这只是因为我让代码更容易可视化，更简洁，更面向逻辑，更不面向例程。

虽然两者都是有效的，但使用第二种方法会使缺乏经验的开发人员不愿意到处放置var语句，从而导致提升问题。如果每个函数只有一个var，在函数的顶部，那么从整体上调试代码会更容易。这可能意味着声明变量的行不像某些人希望的那样显式。

我觉得这种权衡是值得的，如果这意味着让开发者不再在任何他们喜欢的地方使用“var”。

人们可能会抱怨JSLint，我也一样，但是很多JSLint并不是为了修复语言的问题，而是为了纠正编码员的坏习惯，从而防止他们编写的代码出现问题。因此:

在具有块作用域的语言中，通常建议在第一次使用变量的位置声明变量。但是因为JavaScript没有块作用域，所以更明智的做法是在函数的顶部声明函数的所有变量。建议每个函数使用一个var语句。”——http://www.jslint.com/lint.html范围

第一种方法更容易维护。每个声明都是单行上的单个语句，因此可以轻松地添加、删除和重新排序声明。

对于第二种方法，删除第一个或最后一个声明是很烦人的，因为它们分别从var关键字开始并以分号结束。每次添加新声明时，必须将最后一行中的分号替换为逗号。

我认为这是个人喜好的问题。我喜欢用下面的方法做这件事:

   var /* Variables */
            me = this, that = scope,
            temp, tempUri, tempUrl,
            videoId = getQueryString()["id"],
            host = location.protocol + '//' + location.host,
            baseUrl = "localhost",
            str = "Visit W3Schools",
            n = str.search(/w3schools/i),
            x = 5,
            y = 6,
            z = x + y
   /* End Variables */;