Gestion des instances d'objet

Question

Je souhaite créer un nombre d'objets inconnu. Je ne suis pas sûr s'il y a une meilleure façon de les gérer et de les référencer. Permet d'utiliser un exemple de POO standard ... disons chaque fois qu'un utilisateur entre un nom pour un animal de compagnie dans un champ de texte et clique sur un bouton qu'un nouvel objet animal de compagnie est créé via la fonction petFactory.

function pet(name) 
{ 
     this.name= name; 
} 

function petFactory(textFieldInput) 
{ 
     var x = new pet(textFieldInput) 
} 

Comme il n'y a aucun moyen, que je sache (en plus d'une fonction eval), d'utiliser dynamiquement un nouveau nom de variable unique pour l'animal chaque fois petFactory est appelé, x est réaffecté à un nouvel objet et la le dernier animal de compagnie est perdu. Ce que j'ai fait est de pousser l'objet de compagnie sur un tableau dès qu'il est initialisé.

petArray.push(this); 

Donc, si je voulais l'animal nommé « mrFuzzyButtoms » je pouvais boucle à travers un tableau indexé jusqu'à ce que je trouve l'objet avec la variable d'instance « mrFuzzyButtoms »

for (n in petArray) 
{ 
     if (petarray[n].name == 'mrFuzzyBottoms') 
     { 
       // Kill mrFuzzyBottoms 
     } 
} 

ou je pourrais utiliser un tableau associatif ... peu importe ... mais le tableau est la seule méthode que je connais pour le faire. En plus d'utiliser une fonction eval pour créer des noms de variables uniques à partir de chaînes, certaines langues n'ont pas de fonction eval (actionscript3) et il y a aussi le risque de sécurité.

Y a-t-il une meilleure façon de procéder?

Édition: Actuellement, je travaille en Python, JavaScript et ActionScript.

Answer 1

Ce que les classes de collection (listes, dictionnaires/cartes, ensembles) sont pour; pour collecter un certain nombre d'instances. Pour le cas ci-dessus, j'utiliserais probablement une carte (le nom de la classe varie selon la langue) d'un nom à l'autre.

Answer 2

"Je pourrais utiliser un tableau associatif" Correct.

"Le tableau est la seule méthode que je connaisse pour le faire."

Renseignez-vous sur "Mappages" ou "Dictionnaires" dès que vous le pouvez. Vous constaterez qu'il fait exactement ce que vous demandez.

Quelle langue utilisez-vous? Si vous fournissez un langage spécifique, nous pouvons fournir des liens spécifiques vers la structure "Map" dans cette langue.

Answer 3

#!/usr/bin/env python 
"""Playing with pets.  

""" 


class Pet(object): 
    """A pet with a name.""" 
    def __init__(self, name): 
     """Create a pet with a `name`. 

     """ 
     self._name = name 

    @property 
    def name(self): # name is read-only 
     return self._name 

    def __repr__(self): 
     """ 
     >>> eval(repr(self)) == self 
     """ 
     klass = self.__class__.__name__ 
     return "%s('%s')" % (klass, self.name.replace("'", r"\'")) 

    def __eq__(self, other): 
     return repr(self) == repr(other) 

    name2pet = {} # combined register of all pets 

    @classmethod 
    def get(cls, name): 
     """Return a pet with `name`. 

     Try to get the pet registered by `name` 
     otherwise register a new pet and return it 
     """ 
     register = cls.name2pet 
     try: return register[name] 
     except KeyError: 
      pet = register[name] = cls(name) # no duplicates allowed 
      Pet.name2pet.setdefault(name, []).append(pet) 
      return pet 


class Cat(Pet): 
    name2pet = {} # each class has its own registry 


class Dog(Pet): 
    name2pet = {} 


def test(): 
    assert eval(repr(Cat("Teal'c"))) == Cat("Teal'c") 

    pets = [Pet('a'), Cat('a'), Dog('a'), Cat.get('a'), Dog.get('a')] 
    assert all(pet.name == 'a' for pet in pets) 

    cat, dog = Cat.get('pet'), Dog.get('pet') 
    assert repr(cat) == "Cat('pet')" and repr(dog) == "Dog('pet')" 
    assert dog is not cat 
    assert dog != cat  
    assert cat.name == dog.name 

    assert all(v == [Cat(k), Dog(k)] 
       for k, v in Pet.name2pet.items()), Pet.name2pet 

    try: cat.name = "cat" # .name is read-only 
    except AttributeError: 
     pass 

    try: assert 0 
    except AssertionError: 
     return "OK" 
    raise AssertionError("Assertions must be enabled during the test") 


if __name__=="__main__": 
    print test() 

pet.py