La clase Mootools amplía la llamada al método principal anulado

Estoy jugando con la herencia de clases de Mootools, etc. y estoy tratando de llamar a los métodos anulados de las clases base con la propiedad .parent (sry para el fragmento de código largo).

var app = this.app = {},
    //ultimate base class
    Animal = new Class({
        initialize : function(param){
            this.age = param.age;
            this.name = param.name;
        },
        doStuff : function(param){
            alert("animal doStuff");
        }
    }),
    //herbivore functionality
    HerbivoreBehaviour = new Class({
        eat : function(){
            alert('Plants are scrumptious');
        }
    }),
    //carnivore functionality
    CarnivoreBehaviour = new Class({
        eat : function(){
            alert('Meat tastes gooood');
        }
    })
    //mammal base class
    Mammal = new Class({
        Extends : Animal,
        initialize : function(param){
            this.parent(param);
            this.numberOfNipples = param.numberOfNipples;
        },
        doStuff : function(){
            alert("mammal doStuff");
            this.doStuff.parent();
        }
    }),
    //reptile base class
    Reptile = new Class({
        Extends : Animal,
        initialize : function(param){
            this.parent(param);
            this.numberOfScales = param.numberOfScales;
        },
        doStuff : function(){
            alert('reptile doStuff');
            this.doStuff.parent();
        }
    }),
    //final top class animal->mammal-cow!
    //and it's a herbivore
    Cow = new Class({
        Extends : Mammal,
        Implements : HerbivoreBehaviour,
        initialize : function(param){
            this.parent(param);
            this.isMooCrazy = param.isMooCrazy;
        },
        doStuff : function(){
            alert('I am a cow');
            this.doStuff.parent();
        }
    }),
    //final top level class animal->reptile->mutantLizard!
    //and it's a carnivore
    MutantLizard = new Class({
        Extends : Reptile,
        Implements : CarnivoreBehaviour,
        initialize : function(param){
            this.parent(param);
            this.isDestroyingEverything = param.isDestroyingEverything;
        },
        doStuff : function(){
            alert('STOMP STOMP STOMP CRRRRRASH');
            this.doStuff.parent();
        }
    });

    app.run = function(){
        var daisy = new Cow({
                name : 'Daisy',
                age : 2,
                numberOfNipples : 6,
                isMooCrazy : true
            }),
            godzilla = new MutantLizard({
                name : 'Godzilla',
                age : 1123,
                numberOfScales : 123456,
                isDestroyingEverthing : true
            });

        daisy.eat();
        godzilla.eat();
        daisy.doStuff();
        godzilla.doStuff();
    };

la salida actual es correcta de daisy.eat() y godzilla.eat() pero luego la ejecución se detiene después de la primera declaración de impresión de daisy.doStuff() y luego no llama al método daisys parent class doStuff() que es lo que estaba con la esperanza de. ¿Podría decirme cómo llamaría doStuff así?

ACTUALIZACIÓN:

Logré arreglar la secuencia de llamadas reemplazando this.doStuff.parent() con this.parent(). Sin embargo, esto planteó la pregunta de a qué se refiere 'esto'. Pensé que sería la instancia real de la clase, es decir. daisy o godzilla, pero el uso de this.parent() en el método doStuff parecería implicar, al menos para mí, que 'esto' se refiere al objeto Función real en el que se encuentra actualmente, a menos que se llame al método parent() dentro de una función busca automáticamente en qué método se encuentra y llama a su primer método anulado.

preguntado el 12 de junio de 12 a las 22:06

esto se refiere a la instancia, que es un objeto, que es el objeto host del método que está ejecutando. -

1 Respuestas

derecho. bueno, básicamente, todo está bien, esa es la buena noticia. el único cambio requerido es cambiar su this.doStuff.parent() a this.parent() todo al rededor.

http://jsfiddle.net/dimitar/njQBN/

parece funcionar bien.

"Hacer" this.doStuff.parent() para empezar, no es muy DRY, y también hace referencia a una propiedad local, que en el contexto de una clase que extiende e implementa otras con el mismo método, al mismo tiempo, tendrá... resultados inesperados.

Respondido el 13 de junio de 12 a las 09:06

Simplemente pensé que el método doStuff tendría una propiedad 'principal' con la que llamar a su método anulado porque en los Documentos dice "Los métodos de esta Clase que tienen el mismo nombre que la Clase Extends, tendrán una propiedad principal, que le permite llamar al otro método anulado". por eso estaba probando doStuff.parent() pero prefiero la forma real, se ve y se siente mejor. - Daniel Robinson

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.