在JavaScript中,可以像这样声明多个变量:
var variable1 = "Hello, World!";
var variable2 = "Testing...";
var variable3 = 42;
...或者像这样:
var variable1 = "Hello, World!",
variable2 = "Testing...",
variable3 = 42;
一种方法比另一种更好/更快吗?
在JavaScript中,可以像这样声明多个变量:
var variable1 = "Hello, World!";
var variable2 = "Testing...";
var variable3 = 42;
...或者像这样:
var variable1 = "Hello, World!",
variable2 = "Testing...",
variable3 = 42;
一种方法比另一种更好/更快吗?
当前回答
可维护性问题可以很容易地通过一些格式化来解决,比如:
let
my_var1 = 'foo',
my_var2 = 'bar',
my_var3 = 'baz'
;
我严格按照个人喜好使用这种格式。当然,对于单个声明,或者它只是把工作搞砸的情况,我跳过了这种格式。
其他回答
可维护性问题可以很容易地通过一些格式化来解决,比如:
let
my_var1 = 'foo',
my_var2 = 'bar',
my_var3 = 'baz'
;
我严格按照个人喜好使用这种格式。当然,对于单个声明,或者它只是把工作搞砸的情况,我跳过了这种格式。
我相信在我们开始使用ES6之前,使用单一的var声明的方法既不好也不好(如果你有lints和'use strict'的话)。这真的是一种口味偏好。但现在我的情况变了。以下是我对多行声明的一些看法:
Now we have two new kinds of variables, and var became obsolete. It is good practice to use const everywhere until you really need let. So quite often your code will contain variable declarations with assignment in the middle of the code, and because of block scoping you quite often will move variables between blocks in case of small changes. I think that it is more convenient to do that with multiline declarations. ES6 syntax became more diverse, we got destructors, template strings, arrow functions and optional assignments. When you heavily use all those features with single variable declarations, it hurts readability.
是一个很好的特性。没有理由逃避。随着技术的发展,我们也必须自我进化。这个特性在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];
注意,在迁移新样式的代码时,我不仅大量删除了大块的例程代码。我很容易就发现了那些逃避了大量代码审查的不一致之处,这只是因为我让代码更容易可视化,更简洁,更面向逻辑,更不面向例程。
ECMAScript 2015引入了解构赋值,效果非常好:
[a, b] = [1, 2]
A等于1 b等于2。
正如每个人都说的,这主要是偏好和可读性,但我将在这个帖子上发表评论,因为我没有看到其他人分享这样的想法
我认为这个问题的答案很大程度上取决于你所设置的变量以及它们之间的关系。我尝试着基于我所创造的变量是否相关而保持一致;我的偏好大致是这样的:
对于不相关的变量
我把它们排成一行,这样以后可以很容易地移动它们;我个人从来不会以其他方式声明不相关的项目:
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);
我说通常是因为如果输入参数足够长,这会变得不可读,我会把它们分开。
我同意其他人关于严格使用的评论