actionscript-3 - programar - eventos de los botones en flash

ActionScript 3.0 utilizando cierres para controladores de eventos

Question

Intenté hacer esto:

root.addEventListener("click", 
   function () 
   { 
      navigateToURL(ClickURLRequest,"_self"); 
   });

Y agrega el oyente del evento. Me gusta usar cierres porque funcionan bien en esta situación,

sin embargo, eliminar el detector de eventos requiere una referencia a la función original, y como utilicé un cierre anónimo, no funciona, intenté:

   root.removeEventListener("click", 
       function () 
       { 
          navigateToURL(ClickURLRequest,"_self"); 
       });

tanto como:

   root.removeEventListener("click", function () {} );

La única forma en que lo encontré funcionaría fue eliminar el cierre anónimo y señalar a los oyentes del evento en una función preexistente:

 function OnClick (e:Event)
 {
     navigateToURL(ClickURLRequest,"_self");
 }

 root.addEventListener("click", OnClick);
 root.removeEventListener("click", OnClick);

¿Alguien sabe una forma de utilizar cierres anónimos para los manejadores de eventos al tiempo que conserva la capacidad de eliminarlos?

Answer 1

Solo una nota al margen en su código que encontré en el conjunto de tutoriales de Flex In A Week en el sitio web de Adobe. Allí, dijeron que siempre debes usar las constantes para los tipos de eventos en lugar de la cadena. De esa forma obtendrás protección contra errores tipográficos. Si crea un error tipográfico en el tipo de evento cadena (como por ejemplo "clse"), su controlador de eventos se registrará pero, por supuesto, nunca se invocará. En su lugar, use Event.CLOSE para que el compilador detecte el error tipográfico.

Answer 2

No sé lo que estás haciendo en realidad, pero en este ejemplo en particular, quizás podrías tener una variable global _clickEnabled.

Luego, dentro del controlador de eventos, solo debes marcar _clickEnabled, y si es falso, simplemente return inmediatamente.

Luego puede habilitar y deshabilitar el evento general sin desconectarlo ni volver a conectarlo.

Answer 3

No estoy seguro de si esto funcionará, pero vale la pena intentarlo:

root.removeEventListener("click", arguments.callee );

Se puede encontrar más información al respecto Flex lang ref

Answer 4

Puede pensar en la palabra clave function () como un constructor, creando un nuevo objeto (un cierre) cada vez. Por lo tanto, si crea el cierre solo como parámetro y no conserva una referencia en ningún lugar, no hay forma de obtener el cierre "igual" en otro lugar.

La solución obvia es lo que no te gusta, definir la función antes de usarla. Por supuesto, todavía puede ser un cierre completo y no solo una función ''estática''. simplemente defínalo en el contexto que desee y asígnelo a una variable local.

Answer 5

No es demasiado diferente a usar una función definida, pero quizás esto satisfaga tus necesidades. Recuerde que las funciones son objetos de primera clase en ActionScript y que puede almacenarlas y pasarlas como variables.

protected function addListener() { m_handler = function(in_event:Event) { removeEventListener(MouseEvent.CLICK, m_handler); m_handler=null} addEventListener(MouseEvent.CLICK, m_handler) } protected var m_handler:Function

Answer 6

Aquí hay una forma genérica de eliminar los oyentes de eventos que he usado en proyectos de producción

addEventListener
(
    Event.ACTIVATE, 
    function(event:Event):void
    {
        (event.target as EventDispatcher).removeEventListener(event.type, arguments.callee)             
    }
)

Answer 7

Me encontré haciendo esto mucho, así que probé esto. Parece que funciona bien.

addSelfDestructiveEventListener(''roomRenderer'', ''complete'', trackAction, ''floorChanged'');

private function addSelfDestructiveEventListener(listenee:*, event:String, functionToCall:Function, StringArgs:String):void
{
    this[listenee].addEventListener(event, function(event:Event):void
        {
            (event.target as EventDispatcher).removeEventListener(event.type, arguments.callee);
            functionToCall(StringArgs);
        })
}

Answer 8

Yo uso esto a veces:

var closure:Function = null;
root.addEventListener("click", 
   closure = function () 
   { 
      navigateToURL(ClickURLRequest,"_self"); 
   });

root.removeEventListener("click", closure);

Answer 9

Como ya se ha sugerido, puede eliminar el cierre de la cadena de oyentes desde el propio cierre. Esto se hace mediante el uso de arguments.callee:

myDispatcher.addEventListener("click", function(event:Event):void
{
    IEventDispatcher(event.target).removeEventListener(event.type, arguments.callee);

    // Whatever else needs doing goes here
});

Esto efectivamente convertirá el cierre en un oyente único del evento, simplemente separándose una vez que el evento se haya disparado. Aunque es sintácticamente detallado, es una técnica increíblemente útil para los muchos eventos que realmente solo se disparan una vez (o que solo te importan una vez) como "creationComplete" en Flex, por ejemplo. Utilizo esto todo el tiempo cuando descargo datos, ya que creo que tener el código de devolución de llamada en línea hace que sea más fácil de entender. Es como esconder la asincronía-ness:

myLoader.addEventListener("complete", function(event:Event):void
{
    /* Even though the load is asynchronous, having the callback code inline
     * like this instead of scattered around makes it easier to understand,
     * in my opinion. */
});

Sin embargo, si desea escuchar el evento varias veces, esto no será muy efectivo por razones obvias. En ese caso, debe almacenar una referencia al cierre en alguna parte. Los métodos son objetos como cualquier otra cosa en ActionScript y se pueden pasar. Por lo tanto, podemos alterar nuestro código para que se vea así:

var closure:Function;

myDispatcher.addEventListener("click", function(event:Event):void
{
    closure = arguments.callee;

    // Whatever else needs doing goes here
});

Cuando necesite eliminar el detector de eventos, use la referencia ''cierre'', de esta manera:

myDispatcher.removeEventListener("click", closure);

Obviamente, este es un ejemplo abstracto, pero usar cierres como este puede ser bastante útil. Sin embargo, tienen inconvenientes, como ser menos eficientes que los métodos nombrados. Otro inconveniente es el hecho de que en realidad tiene que almacenar una referencia al cierre si alguna vez lo necesita. Se debe tener cuidado para preservar la integridad de esa referencia, al igual que con cualquier otra variable.

Por lo tanto, aunque la sintaxis diferente puede tener sus usos, no siempre es la mejor solución. Es un tipo de cosas de manzanas y naranjas.