两种惰性解决方案

这里已经有了很好的答案，我不是这方面的专家，但我是懒惰方面的专家，以我的专家眼光来看，这些答案似乎不够懒惰。

第一个:从匿名函数返回对象

T.J. Crowder, Henry Wrightson和Rafael Rocha的回答略有不同:

Var foo = (() => { //粘贴原始对象 Const foo = { 5, b: 6, }; //使用它们的属性 foo.c = foo。A + foo.b; //做任何你想做的事情 //最后返回对象 返回foo; }) (); console.log (foo);

稍微有点好处的是，只需要原样粘贴您的原始对象，而不用担心参数等(恕我直言，包装器函数通过这种方式变得相当透明)。

第二:使用setTimeout

如果你不需要立即使用foo.c，这个方法可以工作:

Var foo = { 5, b: 6, c: setTimeout(() => foo.c = foo.c。A + foo。b, 0) }; //首先，foo.c将是setTimeout返回的整数 console.log (foo); //但如果这不是一个问题，当时间进入事件循环时，值将被更新 setTimeout(() => console.log(foo)， 0);

在对象字面量上创建新函数并调用构造函数似乎与原始问题完全不同，而且没有必要。

在对象文字初始化期间不能引用兄弟属性。

var x = { a: 1, b: 2, c: a + b } // not defined 
var y = { a: 1, b: 2, c: y.a + y.b } // not defined 

计算属性的最简单的解决方案如下(没有堆，没有函数，没有构造函数):

var x = { a: 1, b: 2 };

x.c = x.a + x.b; // apply computed property

另一种方法是在给对象赋值之前先声明对象:

const foo = {};
foo.a = 5;
foo.b = 6;
foo.c = foo.a + foo.b;  // Does work
foo.getSum = () => foo.a + foo.b + foo.c;  // foo.getSum() === 22

这样，就可以使用对象变量名访问已经分配的值。 最适合config.js文件。

好吧，我想到了另一个解决方案。这里我想初始化一个对象，表示每个时间单位的毫秒数。 结果是typescript中的enum在我的例子中不能使用，所以我声明了多个变量，并将其分配给一个对象，如下所示:

const SECOND = 1000
const MINUTE = 60 * SECOND
const HOUR = 60 * MINUTE
const DAY = 24 * HOUR
const WEEK = 7 * DAY

export const TimeInMS = {
  SECOND,
  MINUTE,
  HOUR,
  DAY,
  WEEK
}

这种方法的缺点是:

变量被定义为常量，即使我们不需要它们。因此它需要无用的内存。 对象的每个值必须声明为独立的变量

如果你的对象被编写成一个返回对象的函数，并且你使用ES6对象属性“方法”，那么它是可能的:

const module = (state) => ({
  a: 1,
  oneThing() {
    state.b = state.b + this.a
  },
  anotherThing() {
    this.oneThing();
    state.c = state.b + this.a
  },
});

const store = {b: 10};
const root = module(store);

root.oneThing();
console.log(store);

root.anotherThing();
console.log(store);

console.log(root, Object.keys(root), root.prototype);

现在在ES6中，你可以创建惰性缓存属性。在第一次使用时，该属性只计算一次，成为一个正常的静态属性。结果:第二次跳过数学函数开销。

神奇之处在于getter。

const foo = {
    a: 5,
    b: 6,
    get c() {
        delete this.c;
        return this.c = this.a + this.b
    }
};

在箭头getter中，这将拾取周围的词法作用域。

foo     // {a: 5, b: 6}
foo.c   // 11
foo     // {a: 5, b: 6 , c: 11}