Actionscript 3 如何在for循环中管理事件侦听器？

For循环包含一个事件侦听器函数。但循环迭代比侦听器函数快。在侦听器函数完成下一次迭代之前。如何处理这个问题？

听起来你不需要“for”循环

---

根据您的描述，您似乎需要某种形式的事件链，在第一个事件完成后，您可以在其中设置一个新的侦听器，等等……

如果您要寻找的答案与PatrickS描述的一样，我创建了一个如何实现它的示例：

package 
{
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.events.TimerEvent;
    import flash.utils.Timer;

    public class Main extends Sprite 
    {
        private var _queue:Queue;

        public function Main():void 
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);

        }// end function

        private function init(e:Event = null):void 
        {
            removeEventListener(Event.ADDED_TO_STAGE, init);

            var queueItems:Vector.<QueueItem> = new Vector.<QueueItem>();

            for (var i:uint = 0; i < 5; i++)
            {
                var timer:Timer = new Timer(2 * 1000, 1);

                queueItems.push(new QueueItem(timer, TimerEvent.TIMER_COMPLETE, onTimerComplete));

            }// end for

            _queue = new Queue(queueItems);

            var currentTimer:Timer = Timer(_queue.currentQueueItem.eventDispatcher);
            currentTimer.start();

            _queue.shift();

        }// end function

        private function onTimerComplete(e:TimerEvent):void
        {
            if (_queue.currentQueueItem)
            {
                var currentTimer:Timer = Timer(_queue.currentQueueItem.eventDispatcher);
                currentTimer.start();

                if (_queue.length > 0) _queue.shift();

            }// end if

        }// end function

    }// end class

}// end package

import flash.events.IEventDispatcher;
import flash.events.Event;

internal class Queue
{
    private var _queueItems:Vector.<QueueItem>;

    public function get currentQueueItem():QueueItem { return (_queueItems.length > 0) ? _queueItems[0] : null }
    public function get length():int { return _queueItems.length }

    public function Queue(queueItems:Vector.<QueueItem>) 
    {
        _queueItems = queueItems;

    }// end function

    public function shift():void
    {
        var eventDispatcher:IEventDispatcher = _queueItems[0].eventDispatcher;
        var type:String = _queueItems[0].type;
        var listener:Function = _queueItems[0].listener;
        var useCapture:Boolean = _queueItems[0].useCapture;
        var priority:int = _queueItems[0].priority;
        var useWeakReference:Boolean = _queueItems[0].useWeakReference;

        eventDispatcher.addEventListener(type, listener, useCapture, priority, useWeakReference);

        _queueItems.shift();

    }// end function

}// end class

internal class QueueItem
{
    private var _eventDispatcher:IEventDispatcher;
    private var _type:String;
    private var _listener:Function;
    private var _useCapture:Boolean;
    private var _priority:int;
    private var _useWeakReference:Boolean;

    public function get eventDispatcher():IEventDispatcher { return _eventDispatcher }
    public function get type():String { return _type}
    public function get listener():Function { return _listener }
    public function get useCapture():Boolean { return _useCapture }
    public function get priority():int { return _priority }
    public function get useWeakReference():Boolean { return _useWeakReference }

    public function QueueItem(eventDispatcher:IEventDispatcher, type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false)
    {
        _eventDispatcher = eventDispatcher;
        _type = type;
        _listener = listener;
        _useCapture = useCapture;
        _priority = priority;
        _useWeakReference = useWeakReference;

    }// end function

}// end class

包
{
导入flash.display.Sprite；
导入flash.events.Event；
导入flash.events.MouseEvent；
导入flash.events.TimerEvent；
导入flash.utils.Timer；
公共类Main扩展了Sprite
{
私有变量队列：队列；
公共函数Main（）：void
{
if（stage）init（）；
else addEventListener（Event.ADDED_TO_STAGE，init）；
}//端函数
私有函数init（e:Event=null）：void
{
removeEventListener（Event.ADDED_TO_STAGE，init）；
变量队列项：向量。=新向量。（）；
对于（变量i:uint=0；i<5；i++）
{
var定时器：定时器=新定时器（2*1000，1）；
push（新的QueueItem（timer，TimerEvent.timer_COMPLETE，onTimerComplete））；
}//结束
_队列=新队列（queueItems）；
var currentTimer:Timer=Timer（_queue.currentQueueItem.eventDispatcher）；
currentTimer.start（）；
_queue.shift（）；
}//端函数
私有函数onTimerComplete（e:TimerEvent）：无效
{
if（_queue.currentQueueItem）
{
var currentTimer:Timer=Timer（_queue.currentQueueItem.eventDispatcher）；
currentTimer.start（）；
如果（_queue.length>0）_queue.shift（）；
}//如果结束
}//端函数
}//末级
}//端包
导入flash.events.IEventDispatcher；
导入flash.events.Event；
内部类队列
{
私有变量队列项：向量。；
公共函数get currentQueueItem（）：QueueItem{return（_queueItems.length>0）？\u queueItems[0]：null}
公共函数get length（）：int{return\u queueItems.length}
公共函数队列（queueItems:Vector.）
{
_queueItems=queueItems；
}//端函数
公共函数shift（）：void
{
var eventDispatcher:IEventDispatcher=\u queueItems[0]。eventDispatcher；
变量类型：字符串=_queueItems[0]。类型；
var侦听器：函数=_queueItems[0]。侦听器；
var useCapture:Boolean=\u queueItems[0]。useCapture；
变量优先级：int=_queueItems[0]。优先级；
var usewakreference:Boolean=\u queueItems[0]。usewakreference；
addEventListener（类型、侦听器、useCapture、优先级、useWeakReference）；
_queueItems.shift（）；
}//端函数
}//末级
内部类队列项
{
私有var\u事件调度器：IEventDispatcher；
私有变量类型：字符串；
私有变量侦听器：函数；
私有变量_useCapture:Boolean；
私有var_优先级：int；
私有变量usewakreference:Boolean；
公共函数get eventDispatcher（）：IEventDispatcher{return\u eventDispatcher}
公共函数get type（）：字符串{return\u type}
公共函数get listener（）：函数{return\u listener}
公共函数get useCapture（）：布尔{return\u useCapture}
公共函数get priority（）：int{return\u priority}
公共函数get usewakreference（）：布尔{return\u usewakreference}
公共函数QueueItem（eventDispatcher:IEventDispatcher，类型：字符串，侦听器：函数，useCapture:Boolean=false，优先级：int=0，useWeakReference:Boolean=false）
{
_eventDispatcher=eventDispatcher；
_类型=类型；
_监听器=监听器；
_useCapture=useCapture；
_优先级=优先级；
_useWeakReference=useWeakReference；
}//端函数
}//末级

简单地说，这将创建一个类似队列的系统，该系统将事件侦听器添加到队列前端的

IEventListener

对象中，当添加事件侦听器时，队列将发生移动

---

上面显示了如何将其用于

计时器
对象。
获得了一些示例代码。。？无法解释您的目标。@user732251“循环迭代比侦听器函数快”是什么意思？您的意思是，在循环中的下一个对象添加了事件侦听器之前，您添加到对象中的事件侦听器没有接收到事件吗？如果您在描述问题时遇到困难，那么您应该发布一些代码或至少描述项目的目的。我还想知道为什么您首先需要这种功能。@user732251应该详细说明您的问题。提供一些代码示例，正如Marty所说，您所说的“for循环”可以帮助我们破译您的目标。