Überschreiben einer Basisklasse Funktion

In Javascript habe ich einer verzweifelten Notwendigkeit für eine Kind-Klasse zu überschreiben einer base classes privilegierte Funktion. Ich bin nicht sicher, ob dies möglich ist, zu tun, aber es wäre toll, wenn jemand mir sagen konnte, wenn es & wie es zu tun. Wenn das nicht möglich ist, gibt es einen anderen Weg, um zu erreichen, was ich versuche zu tun, in der einfachen code-Beispiel unten?

Ich kann nicht konvertieren, die baseclass-Funktion parseXML() auf public, weil es erfordert den Zugriff auf private Variablen

    function BaseClass()
    {
        var map = {};

        //I cannot make this function public BECAUSE it accesses & changes private variables
        this.parseXML = function( key, value )
        {
            alert("BaseClass::parseXML()");
            map[key] = value;
        }
    }

    function ChildClass()
    {
        BaseClass.call(this);
        this.parseXML = function( key, value, otherData )
        {
            alert("ChildClass()::parseXML()");

            //How can I call the base class function parseXML()?
            //this.parseXML();  //calls this function not the parent function
            //MyClass.prototype.doStuff.call
            BaseClass.prototype.parseXML.call(this, key, value);  //fails
            //BaseClass.prototype.parseXML(); //fails

            //perform specialised actions here with otherData
        }
    }

    ChildClass.prototype = new BaseClass;

    var a = new ChildClass();
    a.parseXML();
möglich, Duplikat der Möglich zum überschreiben eines Basisklassen privilegierte Funktion? ... bitte Bearbeiten Sie die original-Frage statt.
Vorschlag: versuchen Sie nicht zu zwingen, Sichtbarkeit von Methoden in JavaScript. Es ist nicht entworfen, um private-und protected-Methoden. Dokumentieren Sie Ihren code richtig. Markieren Sie diese Methode als private in den Kommentar. Wenn jemand nutzt die Methode sowieso und bricht deshalb seinen code, wenn er verwendet Ihre Bibliothek -> sein problem.
mögliche Duplikate von Aufruf base-Methode unter Verwendung von javascript prototype

InformationsquelleAutor Jake M | 2011-11-07

  1. 16
    function BaseClass() {
    var map = {};
    this.parseXML = function(key, value) {
        alert("BaseClass::parseXML()");
        map[key] = value;
    }
}

function ChildClass() {
    BaseClass.call(this);
    var parseXML = this.parseXML;
    this.parseXML = function(key, value, otherData) {
        alert("ChildClass()::parseXML()");
        parseXML.call(this, key, value);
    }
}

ChildClass.prototype = new BaseClass;

var a = new ChildClass();
a.parseXML();

    Live-Beispiel

    Grundsätzlich cache die privilegierte Methode (die nur definiert, die sich auf das Objekt) und dann rufen Sie in der neuen Funktion, die Sie zuweisen, um die privilegierte Methode name.

    Aber eine elegantere Lösung wäre:

    function BaseClass() {
    this._map = {};
};

BaseClass.prototype.parseXML = function(key, value) {
    alert("BaseClass::parseXML()");
    this._map[key] = value;
}

function ChildClass() {
    BaseClass.call(this);
}

ChildClass.prototype = Object.create(BaseClass.prototype);
ChildClass.prototype.parseXML = function(key, value, otherData) {
    alert("ChildClass()::parseXML()");
    BaseClass.prototype.parseXML.call(this, key, value);
}

var a = new ChildClass();
a.parseXML();

    Live-Beispiel

    Auch bonus-Umsetzung mit pd

    Ich denke, Sie dient zum entfernen der this.parseXML = Teil in der vierten Zeile.
    Ich habe. Behoben, jetzt.
    Was ist der Vorteil der zweiten Methode?
    Ich fand folgenden Artikel sehr hilfreich für das Verständnis des obigen code, und noch wichtiger, die zugrunde liegende Logik, warum es funktioniert: developer.mozilla.org/en-US/docs/Web/JavaScript/...

    InformationsquelleAutor Raynos

  2. -4

    IMO, benötigen Sie einen Javascript-Bibliothek wie Ext Js um diese Aufgabe zu vereinfachen. Trotzdem, das folgende Beispiel veranschaulicht, wie Sie schreiben einige helper-Methoden. Es ist ein Teil einer unveröffentlichten open-source-Projekt, an dem ich arbeite. 

    var JWObject = (function () {

    var jwobj = function (){};

    jwobj.prototype = { };

    return jwobj;

})();

var Prototype = (function () {

    var scopeQueue = [ window ];

    return {

        beginScope: function (namespace) {
            var parts = namespace.split('.');
            for (var i = 0; i < parts.length; i++) {
                var name = parts[i],
                    parent = this.getScope(),
                    part = parent[name];

                if (part && !part.__namespace) {
                    throw Error('/* ERROR MESSAGE */');
                }

                scopeQueue.push(parent[name] = (part || { __namespace: true }));
            }
        },

        endScope: function () {
            if (scopeQueue.length > 1) {
                scopeQueue.pop();
            }
        },

        getScope: function () {
            return scopeQueue.pick();
        },

        define: function (name, members) {

            var scope = this.getScope();

            if (scope[name]) {
                throw Error('The prototype already exist.');
            }

            this.extend(members, {
                scope: scope,
                extend: JWObject,
                statics: {}
            });

            //Getting constructor
            var ctor = (members.constructor === Object) ? function() { } : members.constructor;
            delete members.constructor;

            if (typeof members.extend === 'string') {
                members.extend = scope[members.extend];
            }

            if (!members.extend) {
                throw Error('The base class is not specified.');
            }

            //Deriving from parent type
            ctor.prototype = new members.extend();
            members.super = members.extend.prototype;
            delete members.extend;

            members.statics.__class = true;
            this.extend(ctor, members.statics, true);
            delete members.statics;

            //Adding new members
            this.extend(ctor.prototype, members, true);

            //Adding and returning the created prototype
            return scope[name] = ctor;

        },

        extend: function (expando, members, override) {
            for (var m in members) {
                if (override || !expando[m]) {
                    expando[m] = members[m];
                }
            }
        }

    };

})();

Prototype.extend(Array.prototype, {

    pick: function() {
        return this[this.length - 1];
    }

});

    Hier ist das Ergebnis:

    Prototype.beginScope('Sample');

/**
 * Prototype: Sample.Plugin
 */
Prototype.define('Plugin', {

    init: function() {
        alert('init!');
    }

});

Prototype.beginScope('Extension');

/**
 * Prototype: Sample.Extensions.Plugin
 * Extend   : Sample.Plugin
 */
Prototype.define('Foo', {
    extend: Sample.Plugin,

    init: function() {
        this.super.init.call(this);
        alert('child: init!');
    },

    fun: function() {
        this.init();
    },

    statics: {

        create: function() {
            return new Sample.Extension.Foo();
        }

    }

});

Prototype.endScope();
Prototype.endScope();

    Wie Sie sehen können in dem obigen code, wird das Prototyp-Objekt stellt einige Funktionen zum definieren eines namespace (Prototype.beginScope, Prototype.endScope und Prototype.getScope) oder der Definition eines Prototyps (Prototype.define).

    Können Sie Erben ein Prototyp von einem anderen mit erweitern wie java.

    Prototype.define('Foo', {
    extend: Sample.Plugin,

    Oder rufen Sie die base-class-Methode wie folgt:

        init: function() {
        this.super.init.call(this);

    Auch, jeder Prototyp definieren Sie mit obigen code wird abgeleitet aus JWObject standardmäßig.

    -1 für die Empfehlung einer aufgeblähten overkill-system.
    für Ihre -1. Aber du verpasst "verworren" aus der Liste der Adjektive.
    und andere downvoters Leider kann ich nicht downvote schamlos meine Empfehlung. Aber egal, der Spaß macht, sehe ich dieses system aus meiner Sicht, wie ein RIA-Entwickler. Auf jeden Fall würde ich gerne wissen, eine gute JavaScript-Bibliothek Umstände aus deiner Sicht. 🙂 Vielen DANK
    href="https://github.com/Raynos/pd" >pd wäre ein solides Beispiel für geringes Gewicht OO Zucker für javascript. Das einzige, was fehlt, ist super und es gibt keinen guten Mechanismus für super.

    InformationsquelleAutor Mehdi Golchin

Schreibe einen Kommentar