在JavaScript中,可以像这样声明多个变量:

var variable1 = "Hello, World!";
var variable2 = "Testing...";
var variable3 = 42;

...或者像这样:

var variable1 = "Hello, World!",
    variable2 = "Testing...",
    variable3 = 42;

一种方法比另一种更好/更快吗?


当前回答

是一个很好的特性。没有理由逃避。随着技术的发展,我们也必须自我进化。这个特性在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)的另一个原因是调试。如果在任何赋值行中抛出异常,堆栈跟踪只显示这一行。

如果使用逗号语法定义了10个变量,则无法直接知道哪个变量是罪魁祸首。

单个语句版本没有这种歧义。

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

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

有c背景的人肯定会使用第二种方法

var variable1 = "Hello, World!",
variable2 = "Testing...",
variable3 = 42;

上面的方法看起来更像c语言

是一个很好的特性。没有理由逃避。随着技术的发展,我们也必须自我进化。这个特性在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];

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

“内聚优于耦合”的概念可以更广泛地应用,而不仅仅是对象/模块/函数。它还可以用于以下情况:

OP建议的第二个示例将所有变量耦合到同一个语句中,这使得不可能在不破坏东西的情况下将其中一行移动到其他地方(高耦合)。他给出的第一个例子使得变量分配彼此独立(低耦合)。

从耦合:

低耦合通常是结构良好的计算机系统和良好设计的标志,当与高内聚相结合时,可以支持高可读性和可维护性的总体目标。

所以选择第一个。