Question

我知道这听起来很傻，但现在我的好奇心让我坚持这个想法。是否可以声明一组键/值对，如var collection = {a:"1", b:"2"}，然后有第三对说c: "3" + b.value?

Answer 1

首先，使用属性getter。

请注意，c属于b和c的属性。

var collection = {
  a: 1,
  b: 2,
  get c() {
    return this.a + this.b;
  }
};

console.log(collection.a); // 1
console.log(collection.b); // 2
console.log(collection.c); // 3

第二种方式，在ES5中使用concise method in ES6或更“经典”的函数声明。

请注意c现在是一个功能。

let collection = {
  a: 1,
  b: 2,
  c() {
    return this.a + this.b;
  }
};

console.log(collection.a); // 1
console.log(collection.b); // 2
console.log(collection.c()); // 3 called as a function

第三种方式，使用专用函数进行初始化。

如果您有更复杂的初始化，可能在更多属性上，并且可以像“构造函数”一样工作，这将非常有用。

var collection = {
  a: 1,
  b: 2,
  c: 3,
  init: function() {
    this.c = this.a + this.b;
  }
};
collection.init();
console.log(collection.a); // 1
console.log(collection.b); // 2
console.log(collection.c); // 3

第四种方式，直接在c属性上。

var collection = {
  a: 1,
  b: 2,
  c: undefined
};
collection.c = collection.a + collection.b;
console.log(collection.a); // 1
console.log(collection.b); // 2
console.log(collection.c); // 3

具体针对您的问题，我会使用getter并在b前面附加值“3”来解决它（请注意结果是字符串类型），例如：

var collection = {
  a: 1,
  b: 2,
  get c() {
    return '3' + this.b;
  }
};
console.log(collection.a); //1
console.log(collection.b); //2
console.log(collection.c); //"32"
console.log(typeof collection.c); // string

Answer 2

你不能这样做：

var collection = {
 a: 1,
 b: 2,
 c: a + b
}

但你可以这样做：

var collection = {
 a: 1,
 b: 2
}

collection.c = collection.a + collection.b;

Answer 3

是的，您可以在JavaScript对象中存储函数：

var collection = {a:"1", b:"2"}
var newObj = {c: function(){
      return "3" + collection.b
    }
  }
console.log( newObj.c() );

Answer 4

c: "3" + b它没有执行相同的对象。所以你需要将键和值插入对象.declare来自对象外部的c值

var collection = {
  a: "1",
  b: "2",
}
collection['c'] = '3'+collection.b

console.log(collection)

Answer 5

你无法真正传递那些得到评估的“引用”。表达式在分配之前进行评估。

let obj = {
    a: 1,
    b: 2
};

obj.c = 3 + obj.b;

console.log(obj.c);
> 5

obj.b = 10;
console.log(obj.c);
> 5

如果您真的想做类似的事情，可以使用懒惰评估的形式创建一种新类型的对象。

function Lazy(value) {
  this.value = value;
}

Lazy.prototype.valueOf = function() {
  if (typeof this.value === 'function') {
    return this.value();
  }
  return this.value;
};

Lazy.prototype.toString = function() {
  return this.valueOf() + "";
}

/* Then you can do this.. */
let obj = {
  a: new Lazy(1),
  b: new Lazy(2)
};

/* We have to defer the evaluation of the expression. */
obj.c = new Lazy(() => 3 + obj.b);

console.log(obj.c.toString());

obj.b = 10;
console.log(obj.c.toString());

在Javascript集合中，使用较早值中较早的键/值的值

5 个答案: