Apache flex 如何递归访问子对象的子对象？

我有一个画布，里面有很多组件，同样，里面也有很多组件

getChildren（）仅返回顶级子级。检索所有子对象（子对象的子对象的子对象的子对象等）的最佳方法是什么

嗯，我知道如何通过遍历子对象来实现这一点，但是代码非常混乱。我更喜欢使用一个好的递归函数。以前有人写过这个吗？或者有一个Util类可以这样做吗？

尝试一些可能的方法（注意，如果要收集顶级迭代的所有引用，可以递归返回列表）

功能检查（对象：DisplayObject）：无效
{
if（对象为DisplayObjectContainer）
{
var casted:DisplayObjectContainer=对象作为DisplayObjectContainer
跟踪（“DisplayObjectContainer”，casted.name）
for（变量深度：int=0；深度

私有函数递归（显示：DisplayObjectContainer）：无效{
如果（显示）{
对于（变量i:int=0；i<\u display.numChildren；i++）{
var child:DisplayObject=display.getChildAt（i）；
trace（child.name）；
if（子对象为DisplayObjectContainer）{
recuse（DisplayObjectContainer（child））；
}
}
}

}

函数调用返回函数（obj:DisplayObject）：无效
{
跟踪（对象名称）；
}
//先去看看孩子们。
//最深的物体将首先被访问，以此类推。
//最后参观了舞台。
//使用递归
函数深度优先（对象：显示对象，函数：函数）：无效
{
if（！（DisplayObjectContainer的obj实例））
{
func（obj）；
返回；
}
var p:DisplayObjectContainer=DisplayObjectContainer（obj）；
变量len:Number=p.numChildren；
对于（变量i:Number=0；i

这几乎是相同的解决方案，不是吗？这很顺利，谢谢！更正：_display应该是display西奥：是的，看起来很相似，我在发布我的解决方案时没有看到你的解决方案。所以我拿到支票似乎有点不公平。。。

function inspect(object:DisplayObject):void
{
    if(object is DisplayObjectContainer)
    {
        var casted:DisplayObjectContainer = object as DisplayObjectContainer

        trace("DisplayObjectContainer ", casted.name)

        for(var depth:int = 0; depth < casted.numChildren;depth++)
        {
            inspect(casted.getChildAt(depth))
        }

    }else{

        trace("DisplayObject", object.name );
    }
}


inspect(this)

private function recuse(display : DisplayObjectContainer) : void {
  if(display) {
    for (var i : int = 0;i < _display.numChildren;i++) {
        var child : DisplayObject = display.getChildAt(i);
        trace(child.name);
        if(child is DisplayObjectContainer) {
            recuse(DisplayObjectContainer(child));
        }
    }
}

function theCallbackFunction(obj:DisplayObject):void
{
  trace(obj.name);
}

//Visit the children first.
//Deep most objects will be visited first and so on.
//stage is visited at the end.
//Uses recursion
function depthFirst(obj:DisplayObject, func:Function):void
{
  if(!(obj instanceof DisplayObjectContainer))
  {
    func(obj);
    return;
  }
  var p:DisplayObjectContainer = DisplayObjectContainer(obj);
  var len:Number = p.numChildren;
  for(var i:Number = 0; i < len; i++)
  {
    var child:DisplayObject = p.getChildAt(i);
    depthFirst(child, func);
  }
  func(obj);
}   

//Visit the siblings first.
//stage is visited first, then its children, then the grand children and so on
//No recursion.
function breadthFirst(obj:DisplayObject, func:Function):void
{
  var q:Array = []; 
  q.push(obj);
  var p:DisplayObjectContainer;
  var i:Number, len:Number;
  while(q.length != 0) 
  {     
    var child:DisplayObject = queue.shift();
    func(child);
    if(!(child instanceof DisplayObjectContainer))
      continue;         
    p = DisplayObjectContainer(child);
    len = p.numChildren;
    for(i = 0; i < len; i++) 
      q.push(p.getChildAt(i));
  }     
}

depthFirst(this.stage, theCallbackFunction);
breadthFirst(this.stage, theCallbackFunction);