Javascript 可以将对象文字中的多个属性设置为相同的值吗？

例如，我可以这样做吗

{ 
   a: b: c: d: 1,
   e: 2,
   geh: function() { alert("Hi!") }
}

编辑： 有什么办法可以避免这样做吗

{ 
   a: 1,
   b: 1,
   c: 1,
   d: 1,
   e: 2,
   geh: function() { alert("Hi!") }
}

---

您可以在各种属性之间设置一条相等线：

var foo = {};
foo.a = foo.b = foo.c = "Hello";

或者，您可以创建一个方法来为您进行质量分配：

var foo = {
    setValue: function( props, value ) {
        while ( props.length ) this[ props.pop() ] = value;
    }
}

foo.setValue( [ "a", "b", "c" ] , "Foo" );

此更新（根据最新的JavaScript功能）避免了不必要的已定义变量：

{
  let v;
  var obj = {
     "a": (v = 'some value'),
     "b": v,
     "c": v
  };
}

这意味着

v

不会在块外定义，但

obj

将在块外定义

原始答案 做同样事情的另一种方法是：

var v;
var obj = {
     "a": (v = 'some value'),
     "b": v,
     "c": v
};

---

如果不需要多个局部变量，也可以使用闭包。这种语法似乎很流行（但很难看）：

---

你可以试试这个。这不是你想要的语法糖分（例如，

{a，b，c:1，d:2}

），但这是另一种方法，尽管所有这些答案都很好

(object,fields,value)=>Object.assign(object||{}, ...fields.map(f=>({[f]:value}) ))

说明：

(object,fields,value)=>

获取一个对象（如果您想要一个新对象，请随意重新排列参数顺序，也可以使用Falsy值）

将基于

对象返回一个对象

，并对该对象进行变异。要禁用此功能，只需添加第一个参数object literal，如下所示

object.assign（{}，object |{}，…

...fields.map(f=>({[f]:value}) )

---

将映射到对象的字段数组作为附加参数列表分散到

对象。赋值
['a'，'b'].map（f=>（{[f]：value}））
将给出
[{a:value}，{b:value}]
和
f（…[{a:1}，{b:1}]）
类似于
f（{a:1}，{b:1}）
对象。赋值：
是否完成其余的工作还有另一种方法：使用映射函数


//这将是标准的！
如果（！Object.fromEntries）
Object.fromEntries=entries=>entries.reduce（（o，[key，value]）=>({
……哦，
[键]：值
}), {})
常量setSameValue=（源、道具、值）=>({
…来源：，
…Object.fromEntries(
props.map（prop=>[prop，value]）
)
})
//重要的部分：轻松地做你想做的事！
常量输出=setSameValue（{}，['1'，'01']，'string 1'）
const obj={x:1，y:'hello'}
常量输出2=setSameValue（obj、['1'，'01']、'string1'）
console.log（'output1:'，output）
console.log（'output2:'，output2）
改用
for of
循环

for (let [key, value] of Object.entries(object_name)) {
        object_name[key] = 0; // the value that you want to assign
      }

或者另一种方式：

{...['a', 'b', 'c', 'd'].reduce((obj,prop)=>({...obj, [prop]: 1}), {}) }

通过扩展阵列原型，可以将其包装得相当整齐：

Array.prototype.ditto = function(v) { return this.reduce((o,p)=>({...o, [p]: v}), {}) }

所以现在它可以这样使用：

{ 
    ...['a', 'b', 'c', 'd'].ditto(1),
    ...['e', 'f'].ditto(2)
    geh: function() { alert("Hi!") }
}

说明：
.reduce
从一个空对象
{}
开始，对于每个元素
prop
返回一个对象，该对象是对象中已经存在的对象
…obj
加上一个新属性，其值为1:
[prop]：1
。然后用开头的
…
将这些属性展开到外部对象中

如果您拥有大量的属性，那么reduce并不是最有效的，但您可以将其更改为：

Array.prototype.ditto = function(v) { let o = {}; this.forEach(p => o[p] = v); return o; }

可读性更强，效率更高，但不那么酷？？？
@Lewsterin-刚刚做了，请参见编辑不确定，但您可能必须声明字段并执行链式赋值。在对象文本中，您不能。除此之外，您还可以执行链赋值，如
obj.a=obj.b=obj.c=obj.d=1
。您的第一个示例不起作用。您将得到一个TypeError，因为
foo
尚未分配对象，因此它仍然具有
未定义的值。@user1689607当我在控制台中进行黑客攻击时，它工作了，我感到震惊；显然，我忘了在运行代码之前，我已经用
a
属性声明了
foo
。我在控制台中犯了同样的错误。这个解决方案非常好。当对象被匿名定义时，它也起作用，例如在调用函数时作为直接参数。
{ 
    ...['a', 'b', 'c', 'd'].ditto(1),
    ...['e', 'f'].ditto(2)
    geh: function() { alert("Hi!") }
}

Array.prototype.ditto = function(v) { let o = {}; this.forEach(p => o[p] = v); return o; }