Javascript 起重功能中归还物品的成本

假设我有一个汽车对象，它有一个驱动方法。我可以这样做：

var car = {
  engine: {
    horsepower: 200,
    weight: 980
  },
  owner: {
    firstName: 'bob',
    lastName: 'tom'
  },
  drive: drive
}

function drive(){
  console.log("vrooom!");
}

我利用一个提升的函数定义从对象中抽象出驱动方法的实现。我还可以通过使用返回如下对象的函数来隐藏“配置”：

var car = {
  engine: getEngine(),
  owner: getOwner(),
  drive: drive
}

function drive(){
  console.log("vrooom!");
}

function getEngine(){
  return {
    horsepower: 200,
    weight: 980
  }
}

function getOwner(){
  return {
    firstName: 'bob',
    lastName: 'tom'
  }
}

我很好奇这样做的成本与之前相比是多少，是边际成本吗

我问的原因是，我正在使用angular的UI路由器，并且我开始获得很多状态/路由。如果我能在顶部列出所有状态，这样我就可以看到功能，而不必让开发人员在整个文件中查找他们要查找的状态，那就太好了。保持实现/功能的可搜索性，但在最顶层提供与路由器的接口

以下各项之间的区别（内存/速度方面）：

及

---

按照@trincot运行了一些代码

var time = new Date()
for (var i = 1; i < 10000000; i++){
  var car = {
    engine: getEngine(),
    owner: getOwner(),
    drive: drive
  }

  function drive(){
    console.log("vrooom!");
  }

  function getEngine(){
    return {
      horsepower: 200,
      weight: 980
    }
  }

  function getOwner(){
    return {
      firstName: 'bob',
      lastName: 'tom'
    }
  }
}

var secondTime = new Date()

console.log(' first: ', secondTime - time);

var time=新日期（）
对于（变量i=1；i<10000000；i++）{
var car={
引擎：getEngine（），
所有者：getOwner（），
驱动器：驱动器
}
函数驱动（）{
console.log（“vroom！”）；
}
函数getEngine（）{
返回{
马力：200，
体重：980
}
}
函数getOwner（）{
返回{
名字：“鲍勃”，
姓：“汤姆”
}
}
}
var secondTime=新日期（）
log（'first:'，secondTime-time）；

vs

var time=新日期（）
对于（变量i=1；i<10000000；i++）{
var car={
发动机：{
马力：200，
体重：980
},
所有者：{
名字：“鲍勃”，
姓：“汤姆”
},
驱动器：驱动器
}
函数驱动（）{
console.log（“vroom！”）；
}
}
var secondTime=新日期（）
log（'first:'，secondTime-time）；

---

一千万是当我开始得到1.2秒的差异时。100万时，相差约140毫秒。100000时，差异约为13毫秒

根据@trincot运行了一些代码

var time = new Date()
for (var i = 1; i < 10000000; i++){
  var car = {
    engine: getEngine(),
    owner: getOwner(),
    drive: drive
  }

  function drive(){
    console.log("vrooom!");
  }

  function getEngine(){
    return {
      horsepower: 200,
      weight: 980
    }
  }

  function getOwner(){
    return {
      firstName: 'bob',
      lastName: 'tom'
    }
  }
}

var secondTime = new Date()

console.log(' first: ', secondTime - time);

var time=新日期（）
对于（变量i=1；i<10000000；i++）{
var car={
引擎：getEngine（），
所有者：getOwner（），
驱动器：驱动器
}
函数驱动（）{
console.log（“vroom！”）；
}
函数getEngine（）{
返回{
马力：200，
体重：980
}
}
函数getOwner（）{
返回{
名字：“鲍勃”，
姓：“汤姆”
}
}
}
var secondTime=新日期（）
log（'first:'，secondTime-time）；

vs

var time=新日期（）
对于（变量i=1；i<10000000；i++）{
var car={
发动机：{
马力：200，
体重：980
},
所有者：{
名字：“鲍勃”，
姓：“汤姆”
},
驱动器：驱动器
}
函数驱动（）{
console.log（“vroom！”）；
}
}
var secondTime=新日期（）
log（'first:'，secondTime-time）；

---

一千万是当我开始得到1.2秒的差异时。100万时，相差约140毫秒。100000时的差异约为13毫秒

这样的函数调用的单个成本很小，不值得担心。如果你正在进行成千上万次这样的初始化，这可能是需要考虑的。为什么不通过一些测试来衡量效率呢？我认为不会有任何可测量的性能差异。真正的问题是，你需要确定你是应该在这里使用对象组合还是对象继承（“is-a”vs.“has-a”）。@ScottMarcus你是说为我的状态对象构建一个构造函数/类吗？还要感谢@Pointy，如果你想发布一个答案，我可以帮你检查一下，像这样的函数调用的个人成本是微不足道的，不值得担心。如果你正在进行成千上万次这样的初始化，这可能是需要考虑的。为什么不通过一些测试来衡量效率呢？我认为不会有任何可测量的性能差异。真正的问题是，你需要确定你应该在这里使用对象组合还是对象继承（“is-a”vs.“has-a”）。@ScottMarcus你是说为我的状态对象构建一个构造函数/类吗？还要感谢@Pointy，如果你想发布一个答案，我可以帮你检查一下

var time = new Date()
for (var i = 1; i < 10000000; i++){
  var car = {
    engine: getEngine(),
    owner: getOwner(),
    drive: drive
  }

  function drive(){
    console.log("vrooom!");
  }

  function getEngine(){
    return {
      horsepower: 200,
      weight: 980
    }
  }

  function getOwner(){
    return {
      firstName: 'bob',
      lastName: 'tom'
    }
  }
}

var secondTime = new Date()

console.log(' first: ', secondTime - time);

var time = new Date()

for (var i = 1; i < 10000000; i++){
  var car = {
    engine: {
      horsepower: 200,
      weight: 980
    },
    owner: {
      firstName: 'bob',
      lastName: 'tom'
    },
    drive: drive
  }

  function drive(){
    console.log("vrooom!");
  }

}

var secondTime = new Date()
console.log(' first: ', secondTime - time);