Question

是否可以在javascript中创建对象的多个实例，以便它们都可以同时进行操作/编辑？这与我之前的问题有关：Structure of orders in restaurant。我要做的是保持每个订单对象准备好进行编辑，直到客户准备付款/离开，以便可以根据需要添加新项目或从中删除现有项目 - 并且必须可以为所有订单对象在同一时间。

如果表的数量不是很大 - 比如大约15 - 那么创建一个包含不同表号的15个对象的静态数组会更好吗？

Answer 1

呃，是的 - 琐碎的（粗略的代码警告）：

// your class function
function MyClass(params)
{
  this.foo = params.foo;
  this.bar = params.bar;
  // etc...
}

// object or array to maintain dynamic list o instances
var instances = [];

// create instances in storage object
instances.push(new MyClass({foo:123, bar:456}));
instances.push(new MyClass({foo:'abc', bar:'def'}));

// or alternately by key
instances['mykey'] = new Myclass({foo:'argle',bar'bargle'});

不要创建静态数组，因为只要动态结构足够简单就没有必要。也许我错过了你的问题？

编辑：根据您之前的问题更新更多说明性代码，这是另一种解决问题的方法。

在这一点上，这只是一种教学方式。如果这是真正的应用程序，我会建议您使用服务器端语言对所有这些进行建模 - JS实际上是用于控制UI行为而不是业务对象建模。

var Restaurant = {

    Order   :   function (params)
                {
                    this.id = params.id;
                    this.table = params.table;
                    this.items = [];
                    this.number_of_items = 0;

                    if(!Restaurant.Order.prototype.addItem)
                    {
                        Restaurant.Order.prototype.addItem = function (item)
                        {
                            // assuming name is unique let's use this for an associative key
                            this.items[item.name] = item;

                            this.number_of_items++;

                            //returning the item let's you chain methods
                            return item;
                        }
                    }
                },

    Item    :   function (params)
                {
                    this.name = params.name;
                    this.quantity = params.quantity;
                    this.unit_price = params.unit_price;

                    if(!Restaurant.Item.prototype.price)
                    {
                        Restaurant.Item.prototype.price = function ()
                        {
                            return this.quantity * this.unit_price;
                        }
                    }
                },

    orders  :   [],

    addOrder :  function (order)
                {
                    // assuming id is unique let's use this for an associative key
                    this.orders[order.id] = order;
                    //returning the item let's you chain methods
                    return order;
                }
}

with (Restaurant)
{
    with (addOrder( new Restaurant.Order({id:123, table:456}) )) // chaining!
    {
        addItem( new Restaurant.Item({name: 'foo', quantity: 10, unit_price: 10}) );
        addItem( new Restaurant.Item({name: 'bar', quantity: 100, unit_price: 1}) );
    }
}

var num_items = Restaurant.orders[123].items['foo'].price(); // returns 100

Answer 2

由于您在previous问题上使用了对象文字，我建议您先看一下这种prototypal inheritance技术，它可以让您轻松创建从基础实例继承的新对象实例，例如：

// Helper function
if (typeof Object.create !== 'function') {
    Object.create = function (o) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}

// "Base" order object
var order = {
    id: 0,
    table: 0,
    items: []
};

var orders = [], n = 10;
while (n--) {  // make 10 objects inheriting from order and add them to an array
  orders.push(Object.create(order)); 
}

稍后，您可以访问和操作order数组中的orders个对象：

orders[0].id = 10;
orders[0].table = 5;
orders[0].items.push({
  name: "Beer",
  quantity: 1,
  unit_price: 3
});

在javascript中创建共存对象

2 个答案: