Einfach "Klasse" Instanziierung

Schreiben Sie, dass die vorhandenen Antworten nicht detailliert genug, aber auch nach der Lektüre Ihre konkreten Fragen, ich bin mir nicht ganz sicher, genau welche Teile des Codes sind, werfen Sie für eine Schleife — es hat eine Reihe von kniffligen teilen — so dass ich entschuldige mich im Voraus, wenn diese Antwort geht über Bord mit details über Dinge, die Sie haben schon verstanden!

Seit makeClass ist immer dazu gedacht, genannt zu werden die gleiche Weise, es ist ein bisschen leichter zu Grunde geht, wenn wir entfernen Sie eine Ebene der Dereferenzierung. Diese:

var MyClass = makeClass();

entspricht dies:

function MyClass(args)
{
  if ( this instanceof arguments.callee )
  {
    if ( typeof this.init == "function" )
      this.init.apply( this, args.callee ? args : arguments );
  }
  else
    return new arguments.callee( arguments );
}

Da wir nicht mehr um eine anonyme Funktion, die wir nicht mehr brauchen, die arguments.callee notation: es notwendigerweise bezieht sich auf MyClass, so können wir ersetzen Sie alle Instanzen der es mit MyClass verleiht dieser:

function MyClass(args)
{
  if ( this instanceof MyClass )
  {
    if ( typeof this.init == "function" )
      this.init.apply( this, args.callee ? args : arguments );
  }
  else
    return new MyClass( arguments );
}

wo args ist ein Bezeichner für MyClass's ersten argument, und arguments wie immer, ist ein array-artiges Objekt mit alle von MyClass's Argumente.

Die Zeile, die Sie sind, Fragen, ist nur dann erreicht, wenn die "Klasse" hat eine Funktion namens init in der Prototypen (die "constructor"), also geben wir es ein:

MyClass.prototype.init =
  function (prop)
  {
    this.prop = prop;
  };

Sobald wir das getan haben, betrachten Sie dieses:

var myInstance1 = new MyClass('value');

Innerhalb der Aufruf MyClass, this beziehen sich auf das Objekt konstruiert, so this instanceof MyClass wahr werden. Und typeof this.init == "function" wahr werden, weil wir MyClass.prototype.init eine Funktion sein. So erreichen wir diese Zeile:

this.init.apply( this, args.callee ? args : arguments );

Hier args gleich 'value' (das erste argument), es ist also eine Zeichenfolge, sodass es nicht die callee Eigenschaft; so args.callee ist nicht definiert, die in einem booleschen Kontext bedeutet es ist falsch, so args.callee ? args : arguments entspricht arguments. Daher die obige Zeile ist äquivalent zu dieser:

this.init.apply(this, arguments);

entspricht dies:

this.init('value');

(wenn Sie nicht bereits wissen, wie apply Werke, und wie unterscheidet es sich von call finden Sie https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/apply).

Macht das Sinn so weit?

Anderen Fall zu prüfen, ist dies:

var myInstance2 = MyClass('value');

Innerhalb der Aufruf MyClass, this beziehen sich auf das Globale Objekt (in der Regel window), so this instanceof MyClass wird falsch sein, so erreichen wir diese Zeile:

return new MyClass( arguments );

wo arguments ist ein array-artiges Objekt mit einem einzigen element: 'value'. Beachten Sie, dass dies nicht das gleiche wie new MyClass('value').

Terminologische Anmerkung: So der Aufruf MyClass('value') Ergebnisse in einem zweiten Aufruf MyClass, dieses mal mit new. Ich nenne den ersten Anruf (ohne new) die "äußeren-Aufruf", und den zweiten Aufruf (mit new) die "inneren Ruf". Hoffe, dass das intuitive.

Innerhalb des inneren Ruf zu MyClass, args bezieht sich jetzt auf die äußeren-Aufruf arguments Objekt: statt args wird 'value' haben, ist es nun ein array-artiges Objekt mit 'value'. Und statt args.callee wird nicht definiert, es bezieht sich jetzt auf MyClass, so args.callee ? args : arguments entspricht args. Also die inneren Ruf zu MyClass ruft this.init.apply(this, args) entspricht this.init('value').

Also der test auf args.callee soll unterschieden werden zwischen einer inneren Ruf (MyClass('value') → new MyClass(arguments)) aus einer normal direkten Anruf (new MyClass('value')). Im Idealfall könnten wir ausschließen, dass der test durch ersetzen Sie diese Zeile:

return new MyClass( arguments );

etwas hypothetisches, die wie folgt aussah:

return new MyClass.apply( itself, arguments );

aber JavaScript nicht erlauben, dass die notation (oder äquivalente Schreibweise).

Können Sie sehen, durch die Art und Weise, dass es ein paar kleine Probleme mit Resig code:

• Definieren wir einen Konstruktor MyClass.prototype.init, und dann instanzieren wir die "Klasse" durch das schreiben var myInstance3 = new MyClass();, dann args undefiniert im inneren der Aufruf MyClass, so dass der test auf args.callee wird ein Fehler ausgelöst. Ich denke, dass das ist einfach ein bug auf Resig Teil; jedenfalls, es ist leicht behoben werden durch testen auf args && args.callee statt.
• Wenn unser Konstruktor ersten argument passiert, um tatsächlich eine Eigenschaft namens callee, dann ist der test auf args.callee wird zu einem false positive und die falschen Argumente übergeben werden, in den Konstruktor. Dies bedeutet, dass, zum Beispiel, wir können nicht design-Konstruktor, um eine arguments - Objekt als erstes argument. Aber dieses Problem scheint schwierig zu umgehen, und es lohnt sich wahrscheinlich nicht sorgen zu machen.

Was ist der Unterschied zwischen Argumente und Argumente?

Argumente ist eine array-artige Struktur, die in javascript erstellt, die enthält alle bestanden in paremeters.

Args ist ein parameter der Funktion selbst.

Können args.aufgerufene jemals falsch sein?

Absolut,

function makeClass(){
  return function(args){
    if ( this instanceof arguments.callee ) {
      if ( typeof this.init == "function" )
        this.init.apply( this, args.callee ? args : arguments );
    } else
      return new arguments.callee( arguments );
  };
}
var class = makeClass();
class({callee: false});

Also im Beispiel oben:

 function makeClass(){
  return function(args){
    if ( this instanceof arguments.callee ) {
      if ( typeof this.init == "function" )
        this.init.apply( this, args.callee ? args : arguments );
    } else
      return new arguments.callee( arguments );
  };
}

gibt diese folgende Funktion gespeichert in der Variablen class

function (args) {
   if ( this instanceof arguments.callee ) {
      if ( typeof this.init == "function" )
        this.init.apply( this, args.callee ? args : arguments );
   } else
      return new arguments.callee( arguments );
}

so, wenn ich rufe class({args: false});

arguments.callee == makeClass

so args gibt Ihnen die Möglichkeit zum überschreiben der Standard - arguments erstellt von javascript

Folgende auf Ihrem Titel die Frage eher als die spezifische Frage zu Ihrem Beispiel:

Ich nie wirklich, warum Sie benötigen, es zu erschweren, wie dies. Warum nicht genau dies tun? Es ist ein besseres Beispiel (nach mir) der "einfachen" Klasse Instanziierung in js:

function SomeClass(argument1, argument2) {

    //private variables of this object.
    var private1, private2;

    //Public properties
    this.public1 = 4;
    this.public2 = 10;

    //Private method that is invoked very last of this instantionation, it's only here 
    //because it's more logical for someone who is used to constructors
    //the last row of SomeClass calls init(), that's the actual invokation
    function init() {

    }

    //Another private method
    var somePrivateMethod() {
        //body here
    }

    //Public methods, these have access to private variables and other private methods
    this.publicMethod = function (arg1, arg2) {
        //arguments are only accessible within this method
        return argument1 + argument2;
    }


    init();
}


//And then instantiate it like this:

var x = new SomeClass(1, 2);
//Arguments are always optional in js
alert(x.publicMethod());