Get instances by class name in AS3

I need to get all the instances in my stage according to an especific class name. I'm doi开发者_C百科ng this:

var class_ref:Class = getDefinitionByName('fran.MyOwnClass') as Class;
var element;

for (var i:uint = 0; i < this.parent.numChildren; i++)
{
    element = this.parent.getChildAt(i);
    if (element is class_ref)
    {
        trace('Found element of class fran.MyOwnClass');
    }
}

But I want a better way (more efficiently, without checking all the MCs). Is it possible?

If you can start tracking instances from the very beginning of you application life, I'd recommend simply add event listener:

// in document class constructor, before doing anything else
stage.addEventListener(Event.ADDED, stage_addedHandler);
stage.addEventListener(Event.REMOVED, stage_removedHandler);

private function stage_addedHandler(event:Event):void
{
    var obj:DisplayObject = event.target as DisplayObject;
    // do something, e.g. if (obj is MyClass) objCounter++;
}
...

If you can't track from the beginning, you can't avoid loops.. Just make them more optimized:

var n:int = container.numChildren;
while (n-- > 0)
{
    ...
}

Overriding everywhere addChild() and others — that's simply impossible solution in real projects.

You could keep a list of all the MC's of a certain type by extending the container class and overriding its addChild(), addChildAt(), removeChild() and removeChildAt() functions.

public class MySprite extends Sprite {

    public var ownClasses:Vector.<MyOwnClass> = new Vector.<MyOwnClass>();

    override public function addChild(child:DisplayObject):DisplayObject {
        addOwnClass(child as MyOwnClass);
        return super.addChild(child);
    }

    override public function addChildAt(child:DisplayObject, index:int):DisplayObject {
        addOwnClass(child as MyOwnClass);
        return super.addChildAt(child, index);
    }

    private function addOwnClass(child:MyOwnClass):void {
        if (child) ownClasses.push(child);
    }

    override public function removeChild(child:DisplayObject):DisplayObject {
        removeOwnClass(child as MyOwnClass);
        return super.removeChild(child);
    }

    override public function removeChildAt(index:int):DisplayObject {
        removeOwnClass(getChildAt(index) as MyOwnClass);
        return super.removeChildAt(index);
    }

    private function removeOwnClass(child:MyOwnClass):void {
        if (child) {
            var i:int = ownClasses.indexOf(child);
            if (i != -1) ownClasses.splice(i, 1);
        }
    }

}

Using this class, every time a child is added, you check whether it's a MyOwnClass and if it is you add it to the ownClasses list. Similar for removing children.

Now you can simply access the list when you need it without looping over the MC's.

public class Main extends MySprite
{
    public function Main()
    {
        addChild(new Sprite());
        addChild(new MyOwnClass());
        trace(ownClasses);
    }
}

This will output [object MyOwnClass]