Question

假设我有这个对象：

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

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

Order类：

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

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

Item类：

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

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

实例：

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

现在这就是我想要做的事情：

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

如何使这项工作？我需要以某种方式连接类并将一个原型添加到项目对象。

Jsbin：https://jsbin.com/nofofifuka/edit?html,js,console

Answer 1

您可以使用Array.prototype.map来调用Item中元素的items构造函数。

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

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

或者你可以让你的Item构造函数有一些额外的智能，这样如果没有new调用它就可以实例化自己：

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

然后您可以直接在map：

中使用它

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

Answer 2

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

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

Answer 3

在我看来，这种情况应该反映现实生活中的以下情况：
某个买方（customer）会生成order，其中可能包含许多产品位置（items）。
该项目有其独特的特点，应单独添加到订单中。 Order类：

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

Item类：

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.map(function (item) {
    myOrder.addItem(item.id, ite.title);
});

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

Answer 4

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]的customer，id和title属性像所有的吸气者一样。

为子对象创建原型，javascript

4 个答案: