Création d'objets coexistants dans javascript

Question

Est-il possible de créer plusieurs instances d'un objet dans javascript de sorte qu'elles soient toutes prêtes à être manipulées/éditées en même temps? Cela se rapporte à ma question précédente ici: Structure of orders in restaurant. Ce que j'essaie de faire est de garder chaque objet de commande prêt pour l'édition jusqu'à ce que le client soit prêt à payer/quitter afin que de nouveaux éléments puissent être ajoutés ou supprimés comme souhaité - et cela doit être possible pour tous les objets de commande en même temps.

Si le nombre de tables n'est pas très important - disons environ 15 - serait-il préférable de créer un tableau statique de 15 objets avec des numéros de table différents?

Answer 1

Puisque vous utilisez littéraux d'objet sur votre previous question, je vous suggère de donner un coup d'oeil à cette technique prototypal inheritance, il vous permettra de créer facilement de nouvelles instances d'objets héritant d'une instance de base, par exemple:

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

Plus tard, vous pouvez accéder et manipuler vos objets order dans le tableau orders:

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

Answer 2

Er, oui - trivialement (avertissement de code brut):

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

Ne pas créer un tableau statique parce qu'il n'y a tout simplement pas besoin quand une structure dynamique est assez trivial. Peut-être qu'il me manque quelque chose dans votre question? Edit: mise à jour avec plus de code illustratif basé sur votre question précédente, encore une autre façon de résoudre le problème.

À ce stade cependant, c'est une sorte d'enseignement seulement. Si c'était une application réelle, je vous conseillerais de modéliser tout cela dans un langage côté serveur - JS est vraiment pour contrôler le comportement de l'interface utilisateur et non la modélisation des objets métier.

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