创建子对象的原型，javascript

假设我有一个对象：

var order = {
  customer: 'Joe',
  items: [
    {
      id: 123,
      title: 'VCR',
    }
  ]
};

我想为order和items对象创建逻辑。所以我需要编写一个类来实例化另一个类

订单类别：

function Order(customer, items){
  this.customer = customer;
  this.items = items;
}

Order.prototype = {
  getCustomer: function(){
    console.log(this.customer);
  }
};

 function Order(customer){
      this.customer = customer;
      this.items = [];
    }

    Order.prototype = {
      constructor: Order,
      addItem: function(id, title){
         this.items.push(new Item(id, title)); 
      },
      getCustomer: function(){
        console.log(this.customer);
      }
    };

项目类别：

function Item(id, title){
  this.id = id;
  this.title = title;
}

Item.prototype = {
  getItemId: function(){
    console.log(this.id);
  }
};

function Item(id, title){
  this.id = id;
  this.title = title;
}

Item.prototype = {
  constructor: Item,
  getItemId: function(){
    console.log(this.id);
  }
};

例如：

var myOrder = new Order(order.customer, order.items);

var myOrder = new Order(order.customer);
order.items.map(function (item) {
    myOrder.addItem(item.id, ite.title);
});

myOrder.items[0].getItemId() //123

现在我想做的就是：

myOrder.items[0].getItemId() //123
myOrder.items[0].getCustomer() //Joe

我该怎么做？我需要以某种方式连接这些类，并向item对象添加一个原型

Jsbin:

您可以使用调用

项中元素的
项
构造函数

function Order(order){
    this.customer = customer;
    this.items = order.items.map(function (item) {
         return new Item(item);
    });
}

Array.prototype.map
为源数组中的每个元素调用给定函数一次，并返回一个长度相同的新数组，其中包含调用函数的结果

或者，您可以让您的
项
构造函数具有一些额外的智能，以便在不使用
new
调用时可以实例化自身：

function Item(item){
    if (! (this instanceof Item)) { return new Item(item); }
    this.id = id;
    this.title = title;
}

然后您可以在
地图中直接使用它：

function Order(order){
    this.order = order;
    order.items = order.items.map(Item);
}

我认为，你想要实现的目标与继承无关。您能检查下面的代码是否满足您想要实现的目标吗

function Order(id){
  this.id = id;
  this.items = [];
}

Order.prototype.addItem = function(item) {
  this.items.push(item);
};

Order.prototype.getItems = function() {
  return this.items;
};

Order.prototype.getItem = function(id) {
  for (var i = 0, l = this.items.length; i<l; i++) {
    if (this.items[i].id === id) return this.items[i];
  }

  return;
};

function Item(id, customer) {
  this.id = id;
  this.customer = customer;
}

var order1 = new Order(1);
order1.addItem(new Item(123, 'customer1'));
order1.addItem(new Item(345, 'customer2'));
order1.addItem(new Item(456, 'customer3'));

console.log(order1.getItems());
console.log(order1.getItem(345));

功能顺序（id）{
this.id=id；
此参数为.items=[]；
}
Order.prototype.addItem=函数（项）{
此.items.push（item）；
};
Order.prototype.getItems=函数（）{
归还此物品；
};
Order.prototype.getItem=函数（id）{
对于（var i=0，l=this.items.length；i，这种情况应该反映现实生活中的以下情况：

某些买家（
客户
）下了一份
订单
，该订单可能包含许多产品位置（
项目
）。
这些项目有其独特的特点，应单独添加到订单中。
订单类别：

function Order(customer, items){
  this.customer = customer;
  this.items = items;
}

Order.prototype = {
  getCustomer: function(){
    console.log(this.customer);
  }
};

 function Order(customer){
      this.customer = customer;
      this.items = [];
    }

    Order.prototype = {
      constructor: Order,
      addItem: function(id, title){
         this.items.push(new Item(id, title)); 
      },
      getCustomer: function(){
        console.log(this.customer);
      }
    };

项目类别：

function Item(id, title){
  this.id = id;
  this.title = title;
}

Item.prototype = {
  getItemId: function(){
    console.log(this.id);
  }
};

function Item(id, title){
  this.id = id;
  this.title = title;
}

Item.prototype = {
  constructor: Item,
  getItemId: function(){
    console.log(this.id);
  }
};

例如：

var myOrder = new Order(order.customer, order.items);

var myOrder = new Order(order.customer);
order.items.map(function (item) {
    myOrder.addItem(item.id, ite.title);
});

myOrder.items[0].getItemId() //123

Array.prototype.map
是正确的工具，但为了提供您所要求的逻辑，我认为应该像这样使用它：

function Order(o){
    this.items = o.items.map(function(obj){
        obj.customer = o.customer;
        var r = obj;
        r.getItemId = function(){ console.log(obj.id); };
        r.getItemTitle = function(){ console.log(obj.title); };
        r.getCustomer = function(){ console.log(obj.customer); };
        return r;
    });
}

var myOrder = new Order(order);

myOrder.items[0].getCustomer();
myOrder.items[0].getItemId();
myOrder.items[0].getItemTitle();

考虑到从代码中可以明显看出这一点，我没有在上面添加，但由于第4行（
var r=obj；
）的缘故，您可以使用
myOrder.items[n]
的客户、id和标题属性以及所有getter。
添加一个“订单”属性，并在构建项目时传入order对象。是否有理由让
order
类具有单个元素，即
order
对象？为什么不让
order
对象具有
customer
和
items
字段？也就是说，使
order
成为model表示与对象相同的数据，而不是包装器。@apsillers是的，您是对的。修复了它。@PerStröm您可能还希望对
项的
id
和
title
执行相同的操作。此外，您的
getCustomer
getter不反映更改的代码。请注意，如果OP很关心这一点。（实际上，OP只是改变了代码结构，避免了这个问题，但也使您的答案代码的当前措辞与问题不同。）使用此解决方案，您可以为每个项目获得一个相同的原型。这需要不必要的内存。您有办法将单个原型“提升一级”吗它处理项目逻辑？这实际上有点像原型的工作原理：）类实例化时原型中的东西不会被复制。因此内存中只有一个
getItemId
。我相信客户信息应该属于order类，但当然取决于项目。