Javascript OOP-best practices?

Ich immer mit John resig ' s:

http://ejohn.org/blog/simple-javascript-inheritance/

Es ist einfach und erfordert keinen Rahmen um zu funktionieren.

Meine ideale Objekt für OOP ist wie eine Instanz-Methode mit Prototypen:

Beispiel:

var Users = function()
{
    var _instance;
    this.prototype.getUsername = function(){/*...*/}
    this.prototype.getFirstname = function(){/*...*/}
    this.prototype.getSecurityHash = function(){/*...*/}
    /*...*/

    /*Static Methods as such*/
    return { /*Return a small Object*/
        GetInstance : function()
        {
            if(_instance == null)
            {
                _instnance = new Users(arguments);
            }
            return _instnance; //Return the object
        },
        New: function()
        {
            _instnance = null; //unset It
            return this.GetInstnace(arguments);
        }
    }
}

Dann würde ich immer verwenden, wie:

Firstname = Users.GetInstance('Robert','Pitt').getFirstname();
Username  = Users.GetInstance().getUsername(); //Returns the above object.

Me  = Users.New('Robert',null); //Deletes the above object and creates a new instance.
Father = Users.New('Peter','Piper'); //New Object
Me.AddFather(Father); //Me Object.

- Und das ist die Art von Straße, in der ich nach unten gehen, wenn es um den Aufbau einer JavaScript-OO-Stil-Architektur.

//Create and define Global NameSpace Object
( function(GlobalObject, $, undefined) 
{
    GlobalObject.Method = function()
    {
        ///<summary></summary>
    }

    GlobalObject.Functionality = {};

}) (GlobalObject = GlobalObject || {}, jQuery);

//New object for specific functionality
( function(Events, $, undefined)
{
    //Member Variables 
    var Variable; //(Used for) , (type)

    //Initialize
    Events.Init = function()
    {
        ///<summary></summary>
    }

    //public method
    Events.PublicMethod = function(oParam)
    {
        ///<summary></summary>
        ///<param type=""></param>
    }

    //protected method (typically define in global object, but can be made available from here)
    GlobalObject.Functionality.ProtectedMethod = function()
    {
        ///<summary></summary>
    }

    //internal method (typically define in global object, but can be made available from here)
    GlobalObject.InternalMethod = function()
    {
        ///<summary></summary>
    }

    //private method
    var privateMethod = function()
    {
        ///<summary></summary>
    }
}) (GlobalObject.Funcitonality.Events = GlobalObject.Funcitonality.Events || {}, jQuery )

//Reusable "class" object
var oMultiInstanceClass = function()
{
    //Memeber Variables again
    var oMember = null; //

    //Public method
    this.Init = function(oParam)
    {
        oMember = oParam;

        for ( n = 1; i < oMemeber.length; i += 1 )
        { 
           new this.SubClass.Init(oMember[i]); //you get the point, yeah?
        }
    }

    this.Subclass = function()
    {
        this.Init = function() { }
    }
}

Die Stärke liegt darin, dass es initialisiert das Globale Objekt automatisch, können Sie die Integrität Ihres Codes und organisiert jedes Stück Funktionalität in einer bestimmten Gruppierung, die durch Ihre definition.

Diese Struktur ist solide, die Darstellung der grundlegenden syntaktischen Dinge, die Sie erwarten würden von OOP, ohne die wichtigsten Wörter.

Gibt es auch einige geniale Möglichkeiten für die Einrichtung der Schnittstellen als auch. Wenn Sie wählen, so weit zu gehen, eine einfache Suche wird Ihnen einige gute tutorials und tips.

Sogar einrichten intellisense ist möglich mit javascript und visual studio, und definieren jedes Stück und auf Sie vereinfacht das schreiben von javascript-cleaner und übersichtlicher.

Mit diesen drei Methoden benötigt, die von Ihrer situation hilft, die globalen Namensraum sauber, halten Sie Ihren code organisiert und pflegt die Trennung von Bereichen für jedes Objekt.. wenn richtig eingesetzt. Denken Sie daran, Object-Oriented Design ist nutzlos, wenn Sie nicht nutzen Sie die Logik hinter der Verwendung von Objekten!

Ich einen solchen Muster-und empfehlen Sie es benutzen zu:

function Person(firstname, lastname, age)
{
  var self = this;
  var _ = {};

  //Private members.  
  var firstname  = firstname;
  var lastname = lastname;
  var age = age || 'unknown';

  //Private methods.
  function first_letter_to_uppercase(str) {
    return str.charAt(0).toUpperCase() + str.substr(1);
  }

  //Public members and methods.
  _.get_age = function()
  {
    return age;
  }

  _.get_name = function()
  {
    return first_letter_to_uppercase(firstname) + ' ' +
      first_letter_to_uppercase(lastname);
  }
  return _;
}

var p = new Person('vasya', 'pupkin', 23);
alert("It's "  + p.get_name() + ', he is ' + p.get_age() + ' years old.')