Prototype, over-erving van props

[That Guy]

Yo,

Aanschouw deze code:

//js
MainStuff = function()
{
   this.something = "Hello";
}

Nu wil ik iets in deze richting bereiken:

//js
var omg = new MainStuff();

omg.general.aFunc();

dus, ik probeer dit:

//js
MainStuff.prototype.general = function()
{
   this.aFunc = function()
   {
      alert('test');
   }
}

en dat werkt natuurlijk. Maar, ik kan niet de 'something' prop opvragen van de MainStuff, want dit werkt niet:

//js
MainStuff.prototype.general = function()
{
   this.aFunc = function()
   {
      alert(this.something);
   }
}

dan krijg je een mooie 'undefined'.


Weet iemand dus hoe je dit kan oplossen? Ik heb ook al het volgende geprobeert:

//js
MainStuff.prototype.general = function(){} //niet belangrijk nu

MainStuff.prototype.general.aFunc = function()
{
   alert(this.something);
}

en

MainStuff.prototype.general = 
{
   aFunc: function()
   {
      alert(this.something);
   }
}

en nog meer, maar het werkte allemaal niet, hoewel het wel valide code is.


Alvast bedankt.

 

[StijnDeWitt]

Met je eerste voorbeeld creer je een constructor functie. Die creert een nieuw object en zet het attribuut something op 'Hello'. Binnen de constructor functie wijst this naar het nieuw gecreerde object.

In je derde codevoorbeeld creer je weer een constructor functie. The this in die functie wijst naar weer een nieuw object.

Wat je nu probeert kan nooit:

omg.general.aFunc();

omg is een instantie van MainStuff met attribuut something. general is ook een attribuut van MainStuff en aFunc is weer een attribuut van general:

MainStuff
   +-- something
   +-- general
          +-- aFunc

De this van aFunc kan nooit naar MainStuff's attributen wijzen.

Als je namespaces probeert te emuleren, probeer dan eens dit:

var MainStuff = {
  something: 'hello',
  general: {
    aFunc: function() {
      alert(MainStuff.something);
    }
  }
};

MainStuff.general.aFunc();

Jij wil geloof ik dat je MainStuff als een object kunt instantieren. Dat kan in principe, zoals je zelf ook al liet zien, maar dan moet je die logica eigenlijk doortrekken en general op dezelfde manier creeren. Vervolgens kun je het attribuut something verplaatsen naar general en dan wijst de this van aFunc wél naar something... Maar de code in pure javascript wordt er niet mooier van (imho).

Als je classes en namespaces probeert te emuleren, dan wordt het denk ik tijd dat je eens op het linkje in mijn sig klikt, want laat ik daar nu net een mooie oplossing voor hebben gebouwd, Packages JS. Deze gebruikt een functie Package en een speciaal object Class om te bereiken wat jij (denk ik) ook probeert.

 

[That Guy]

Ik kan wel aardig wat met javascript, maar dit is allemaal nieuw, dus ben een beetje verward.

Zoals je zei, ik probeer zoiets te bereiken:

MainStuff()
   +-- something
   +-- general
          +-- aFunc()
          +-- aProp
    +-- bla
          +-- ...
          +-- ...

Daarbij wil ik de 'MainStuff' als object hebben, dus zo aanroepen:

//js
var bla = new MainStuff('bla')

de 'bla' als parameter moet in de '(this.)something' gezet worden. Daarna is het de bedoeling dat alle methods uit 'lagere' niveau's (zoals aFunc() in 'general') deze waarde kunnen lezen.

Als dit niet kan, is het anders wel mogelijk om een functie te schrijven die deze waarde leest? Zonder dus een nieuw object MainStuff te maken, want het gaat erom dat deze 1x aangeroepen wordt met een parameter ('bla' hierboven).


Zoals je zelf al zei, heb naar je site gekeken, maar ik snap niet precies hoe dit werkt en p) hoe ik dit dan zou moeten gebruiken, als het zou helpen met dit probleem.


Alvast bedankt:thumb: