eliminar un oyente que tiene una función anónima en Actionscript 3

Question

up.addEventListener(MouseEvent.CLICK, 
    function clickFunc(event:MouseEvent):void 
    { 
     revealSpinner(event,51.42,1,spinner); 
     event.currentTarget.removeEventListener(event.type, arguments.callee); 
     autoTimer.stop(); 
    }, 
    false, 0, true); 
down.addEventListener(MouseEvent.CLICK, 
    function clickFunc(event:MouseEvent):void 
    { 
     revealSpinner(event,51.42,-1,spinner); 
     event.currentTarget.removeEventListener(event.type, arguments.callee); 
     autoTimer.stop(); 
    }, 
    false, 0, true); 

El código anterior agrega un oyente a un par de MC. Originalmente, los métodos eran anónimos, pero los he llamado clickFunc() para intentar una referencia en mi remove listener.

Aquí está mi código de eliminación de oyentes. Ambos fragmentos están en funciones separadas. El método add listener se llama antes del método remove.

up.removeEventListener(MouseEvent.CLICK, clickFunc); 
down.removeEventListener(MouseEvent.CLICK, clickFunc); 

Tan pronto como el publico la película que sale este error:

1120: Access of undefined property clickFunc. 

Answer 1

probar esto:

up.addEventListener(MouseEvent.CLICK, 
    clickFunc = function(event:MouseEvent):void 
    { 
     revealSpinner(event,51.42,1,spinner); 
     event.currentTarget.removeEventListener(event.type, arguments.callee); 
     autoTimer.stop(); 
    }, 
    false, 0, true); 

down.addEventListener(MouseEvent.CLICK, 
    clickFunc = function(event:MouseEvent):void 
    { 
     revealSpinner(event,51.42,-1,spinner); 
     event.currentTarget.removeEventListener(event.type, arguments.callee); 
     autoTimer.stop(); 
    }, 
    false, 0, true); 

Answer 2

Esto se debe trabajar ... sólo quitar el nombre méthode ...

up.addEventListener(MouseEvent.CLICK, 
     function(event:MouseEvent):void 
     { 
      revealSpinner(event,51.42,1,spinner); 
      event.currentTarget.removeEventListener(event.type, arguments.callee); 
      autoTimer.stop(); 
     }, 
     false, 0, true); 
    down.addEventListener(MouseEvent.CLICK, 
     function(event:MouseEvent):void 
     { 
      revealSpinner(event,51.42,-1,spinner); 
      event.currentTarget.removeEventListener(event.type, arguments.callee); 
      autoTimer.stop(); 
     }, 
     false, 0, true); 

Answer 3

En primer lugar, usted tiene la mismo nombre utilizado dos veces (clickFunc), no se puede inferir a cuál se refiere en sus llamadas a removeEventListener. En segundo lugar, clickFunc sólo será accesible en la función donde se declara:

function foo() { 
    var clickFunc: Function; 
    up.addEventListener(MouseEvent.CLICK, 
     clickFunc = function (event:MouseEvent):void 
     { 
      revealSpinner(event,51.42,1,spinner); 
      event.currentTarget.removeEventListener(event.type, arguments.callee); 
      autoTimer.stop(); 
     }, 
     false, 0, true); 

    // 'clickFunc' available here, so this is possible: 
    up.removeEventListener(MouseEvent.CLICK, clickFunc); 
} 

function bar() { 
    // 'clickFunc' is not available here, so this is not possible: 
    up.removeEventListener(MouseEvent.CLICK, clickFunc); 
    // 1120: Access of undefined property clickFunc 
} 

Si necesita hacer referencia a los métodos (como, por ejemplo, la eliminación de ellos de un evento), no pueden ser anónimas. Si necesita hacer referencia a ellos desde varios métodos, entonces no deberían ser locales para un método (foo en el ejemplo anterior). Y necesitan diferentes identificadores (clickFunc1 y clickFunc2 si lo desea). Esta es mi propuesta de solución:

private function addHandlers(): void 
{ 
    up.addEventListener(MouseEvent.CLICK, upClickHandler, false, 0, true); 
    down.addEventListener(MouseEvent.CLICK, downClickHandler, false, 0, true); 
} 

private function removeHandlers(): void 
{ 
    up.removeEventListener(MouseEvent.CLICK, upClickHandler); 
    down.removeEventListener(MouseEvent.CLICK, downClickHandler); 
} 

private function upClickHandler(event:MouseEvent):void 
{ 
    revealSpinner(event,51.42,1,spinner); 
    event.currentTarget.removeEventListener(event.type, arguments.callee); 
    autoTimer.stop(); 
} 

private function downClickHandler(event:MouseEvent):void 
{ 
    revealSpinner(event,51.42,-1,spinner); 
    event.currentTarget.removeEventListener(event.type, arguments.callee); 
    autoTimer.stop(); 
} 

Por supuesto, si, como en el ejemplo, los métodos son idénticos puede utilizar una sola:

private function addHandlers(): void 
{ 
    up.addEventListener(MouseEvent.CLICK, clickHandler, false, 0, true); 
    down.addEventListener(MouseEvent.CLICK, clickHandler, false, 0, true); 
} 

private function removeHandlers(): void 
{ 
    up.removeEventListener(MouseEvent.CLICK, clickHandler); 
    down.removeEventListener(MouseEvent.CLICK, clickHandler); 
} 

private function clickHandler(event:MouseEvent):void 
{ 
    revealSpinner(event,51.42,-1,spinner); 
    event.currentTarget.removeEventListener(event.type, arguments.callee); 
    autoTimer.stop(); 
} 

Answer 4

bien hay algunas maneras que usted puede hacer esta. esta es la primera manera que creo que es lo que estás buscando.

var upAnon:Function; 
var downAnon:Function; 

up.addEventListener(MouseEvent.CLICK, 
    upAnon = function (event:MouseEvent):void 
    { 
     revealSpinner(event,51.42,1,spinner); 
     event.currentTarget.removeEventListener(event.type, arguments.callee); 
     autoTimer.stop(); 
    }, 
    false, 0, true); 
down.addEventListener(MouseEvent.CLICK, 
    downAnon = function (event:MouseEvent):void 
    { 
     revealSpinner(event,51.42,-1,spinner); 
     event.currentTarget.removeEventListener(event.type, arguments.callee); 
     autoTimer.stop(); 
    }, 
    false, 0, true); 

up.removeEventListener(MouseEvent.CLICK, upAnon); 
down.removeEventListener(MouseEvent.CLICK, downAnon); 

y esta es otra manera, obteniendo el mismo efecto y funcionalidad deseados que el primero. una práctica más limpia y usualmente estándar.

function upFunction(event.MouseEvent):void { 
    revealSpinner(event,51.42,1,spinner); 
    event.currentTarget.removeEventListener(event.type, arguments.callee); 
    autoTimer.stop(); 
} 
function downFunction(event.MouseEvent):void { 
    revealSpinner(event,51.42,-1,spinner); 
    event.currentTarget.removeEventListener(event.type, arguments.callee); 
    autoTimer.stop(); 
} 

up.addEventListener(MouseEvent.CLICK, upFunction, false, 0, true); 
down.addEventListener(MouseEvent.CLICK, downFunction, false, 0, true); 

up.removeEventListener(MouseEvent.CLICK, upFunction); 
down.removeEventListener(MouseEvent.CLICK, downFunction); 

La razón por la que se usaría el primer tipo, es si estuviera creando el manejador de sucesos dentro de una función y la necesidad de utilizar las variables definidas en función de que, dentro de su función anónima. por ejemplo, aquí estoy accediendo a var countMe dentro de la función anon e incrementándola en mouse_down, y se incrementará hasta que mouse_up se active. así que cada vez que presiono, contará desde 0 hasta que el mouse esté arriba, y luego comenzará de nuevo.

var anonFunc:Function; 

function doThisStuff(event:MouseEvent):void { 
    var countMe = 0; 

    stage.addEventListener(Event.ENTER_FRAME, 
     anonFunc = function (e:Event) { 
      countMe++; 
      trace(countMe); 
     } 
    ); 
} 

function stopCounting(event:MouseEvent):void { 
    stage.removeEventListener(Event.ENTER_FRAME, anonFunc); 
} 

stage.addEventListener(MouseEvent.MOUSE_DOWN, doThisStuff); 
stage.addEventListener(MouseEvent.MOUSE_UP, stopCounting); 

Answer 5

Está creando los controladores de eventos con referencias débiles (pasando verdadero para ese último parámetro). Como probablemente ya sepa, una referencia débil no evitará que el recolector de basura recopile su función. Sin embargo, a menos que mantenga una referencia a los manejadores de su evento fuera del alcance de la función en la que los está definiendo (no parece que lo esté), los manejadores solo tendrán esa referencia débil para mantenerlos vivos tan pronto como sea posible. el recolector de basura se ejecuta, sus controladores se han ido de todos modos.La conclusión es que los controladores de eventos no parecen disparar una vez que la recolección de basura se ejecuta, por lo que preocuparse por quitar los controladores es inútil. Se irán por su cuenta, lo quieras o no.

Deberá mantener una referencia a esos controladores de eventos en un ámbito que todavía existirá cuando se activen. Una vez que haya hecho eso, debería poder usar esas referencias para eliminarlos.