Geschachtelte Klasse in javascript Vererbung von privaten Methoden

Verschlüsse sind eine lexikalische Funktion, nicht eine semantische. Wenn sich das Objekt außerhalb der lexikalischen Umfang von anderen, kann es nicht mehr werden "verschachtelt" und den Zugang der ehemaligen lokalen Variablen. In den code der verschachtelten Funktion/Klasse, es gibt keine solche Sache wie this.privateMethod, weil privateMethod ist nie gemacht zu werden, eine Eigenschaft der MainObject. Es ist einfach eine lokale variable innerhalb einer Funktion.

Gibt es keine solche Dinge wie "private Liegenschaften", "private Methoden" oder "private member" in JavaScript. Hölle, es gibt keine solche Sache wie eine "Klasse". Einige Leute mögen zu emulieren, private Mitglieder, die mit lokalen Variablen wie oben, aber dies führt in Fällen wie diesem, wo die Diskrepanz zwischen den beiden Konzepten kommt und beißt einem in den Hintern.

Zum Abschluss, es ist eine schlechte Idee, das schreiben von Java-code, mit all seinen OO-Techniken in JS, wie es ist eine schlechte Idee, zu schreiben C-code, mit all seinen Zeigern und unbegrenzten Puffer, in C#. Sicher, in beiden Fällen können Sie es tun, aber Sie würde scheitern, zu schätzen und zu nutzen, die Sprache bietet diese Möglichkeit.

Und jetzt, wo ich fertig bin mit schimpfen, Sie können so etwas wie dies tun, um "Namespace" - Funktionen:

MainObject = function() {
    var privateVariable = "I'm private";

    var privateMethod = function() {
        alert('Private');
    }

    this.publicMethod = function() {
        alert('Public');
    }

    this.nested = {
      publicNestedMethod: function() {
        privateMethod();
      }
    };

    //or

    this.nested = (function() {
      var nestedPrivate = 5;

      return {
        publicNestedMethod: function() {
          alert(nestedPrivate);
          privateMethod();
        }
      };
    })();
}

MyObject = new MainObject();

MyObject.publicMethod();
MyObject.nested.publicNestedMethod();​

InformationsquelleAutor Max Shawabkeh

Gut zu nutzen prototypal inheritance, wo alle "Unterklassen", die gemeinsam eine einzige Instanz der Methode, die im Prototypen, aber AUCH die Funktion von Erben private Instanzen...
Ich kam mit:

function Person(name,latentPower){
    var privatesForChildren =   { password:"xyz"
                                 ,latentPower:"invisibility"}
    this.inherit = function(){
        for(v in privatesForChildren){
            eval("var " + v + "=privatesForChildren['" + v + "'];");
        }
    }
    this.name = name;
    this.revealName = function(){ alert("My name is" + this.name + "."); }  
    this.revealPowers = function(){ alert("I'm normal."); } 
}       
function Mutant(name,latentPower,fuel){
    this.inherit.call(this);   //Inherit private instance variables
    var fuel = fuel;
    this.name = name;
    this.revealPowers = function(){
    alert("I manifest the powers of " + latentPower + " when I " + fuel + ".");
    }
}
Mutant.prototype = new Person;
Mutant.prototype.constructor = Mutant;

bob = new Person("Bob","telekenesis");
jim = new Mutant("Jim","nausea","eat pizza");
buford = new Mutant("Buford","Teflon Man","breathe");

jim.revealName(); //Inherited properly from prototype
bob.revealPowers();
jim.revealPowers();
buford.revealPowers();  //distinct from Jim's so is an "instance var"
alert(bob.latentPower); //returns undefined 
alert(buford.latentPower); //returns undefined, so is "private".

Wie sinnvoll ist das?

InformationsquelleAutor Brett

Es ist eine Konvention. Sie können imitieren OO Java-Techniken wie private Mitglieder, aber das ist nicht empfehlenswert. Sie können imitieren auf diese Weise:

MyFunction = function(options){
   var private = {};
   //to reference MyFunction as a context
   var that = this;

   function privateFunctionThatCallPublicMethod(){
      that.publicFunction("hello");
   }

   this.publicFunction = function(params){
      alert(params + "  " + private);  
   }
   ...
}

var instance = new MyFunction({oneOption:'fsdfsad'});

Dies ist die besten Ansatz, den ich gefunden zu emulieren OO Java-Techniken...

Aber es ein problem gibt, ist sehr ineffizient...
Müssen Sie mit Prototypen statt, da es sonst schaffen würde, die ein Objekt pro Funktion pro Instanz von "Klasse".

MyFunction = function(options){
   this._private = {};
}

MyFunction.prototype._privateFunctionThatCallPublicMethod = function(){
   this.publicFunction("hello");
}

MyFunction.prototype.publicFunction = function(params){
   alert(params + "  " + this._private);  
}

Wie Sie denken, private Mitglieder sind (auf diese Weise) eine Konvention.
Auch, es ist eine andere Sache, die Sie wissen müssen...

Wenn Sie übergeben eine Funktion ein Objekt als parameter an eine andere Funktion, Sie müssen binden den Kontext der Funktion...

function bind(fnThis, fn) {
  return function(){
    return fn.apply(fnThis, arguments);
  };
}

function makeSomething(callback){
  callback("hello");
}

var instance = new MyFunction();
makeSomething(bind(instance, instance.publicFunction));

Dies ist, weil Sie gebunden werden muss "dieses" als Instanz in den Körper des publicFunction, sonst ist gonna be "Fenster" statt.

InformationsquelleAutor mpccolorado