你可以这样做

var a, b
var foo = {
    a: a = 5,
    b: b = 6,
    c: a + b
}

当我必须引用函数最初声明的对象时，该方法已被证明对我有用。以下是我如何使用它的一个最小示例:

function createMyObject() {
    var count = 0, self
    return {
        a: self = {
            log: function() {
                console.log(count++)
                return self
            }
        }
    }
}

通过将self定义为包含print函数的对象，允许函数引用该对象。这意味着如果您需要将print函数传递到其他地方，则不必将其“绑定”到对象。

如果您愿意，可以使用下面所示的方法

function createMyObject() {
    var count = 0
    return {
        a: {
            log: function() {
                console.log(count++)
                return this
            }
        }
    }
}

然后下面的代码将记录0,1,2，然后给出一个错误

var o = createMyObject()
var log = o.a.log
o.a.log().log() // this refers to the o.a object so the chaining works
log().log() // this refers to the window object so the chaining fails!

通过使用self方法，可以保证print总是返回相同的对象，而不管函数在什么环境中运行。当使用createMyObject()的self版本时，上面的代码将正常运行并记录0、1、2和3的日志。

这个解决方案如何?它也适用于带有数组的嵌套对象

      Object.prototype.assignOwnProVal
     = function (to,from){ 
            function compose(obj,string){ 
                var parts = string.split('.'); 
                var newObj = obj[parts[0]]; 
                if(parts[1]){ 
                    parts.splice(0,1);
                    var newString = parts.join('.'); 
                    return compose(newObj,newString); 
                } 
                return newObj; 
            } 
            this[to] = compose(this,from);
     } 
     var obj = { name : 'Gaurav', temp : 
                  {id : [10,20], city:
                        {street:'Brunswick'}} } 
     obj.assignOwnProVal('street','temp.city.street'); 
     obj.assignOwnProVal('myid','temp.id.1');

如果你想使用原生JS，其他答案提供了很好的解决方案。

但是如果你愿意写自引用对象，比如:

{ 
  a: ...,
  b: "${this.a + this.a}",
}

我写了一个叫做self- references -object的npm库，它支持这种语法并返回一个原生对象。

可维护性很好的替代语法:

let a = 5;
let b = 6;
let foo = {
  a,
  b,
  c: a+b,
};

这是因为如果您没有显式地指定名称，JavaScript将使用变量名作为新创建的对象的属性名。对于像这样的短数组，如果在函数中，我个人会使用单行语法和return:

let a = 5;
let b = 6;
return { a, b, c:a+b };

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

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文件。

两种惰性解决方案

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

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

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);