Hvad er det nu det hedder, og hvordan er det dét fungere?

prototype ?

http://www.javascriptkit.com/javatutors/proto.shtml

jquery er vist også bygget sådan

no no, det var ingen extension. Hvis jeg ikke husker meget forkert, var det ved brug af noget array/var ting ...

var myNamespace = {
function somethingOtherFunction(pet);
function initialize();


somethingFunction(pet) {
alert("du elsker din "+pet);
}

initialize() {
  somethingFunction("hund");
}
};

window.onload = function() { myNamespace.initialize(); };


Ovenstående er bare et eksempel ud fra hvad jeg husker. Syntaksen er sikkert forkert på punkter, men jeg er ret sikker på det var noget i den stil.

oh, den øverste somethingOtherFunction skulle selvfølgelig være somethingFunction ;)

Syntaxen er så vidt jeg husker:

var myNamespace = {
  somethingOtherFunction: function(pet) {
      alert("du elsker din "+pet);
  },
  initialize: function () {
      somethingOtherFunction("hund");
  }
};

hvad så med variable i det myNamespace-scope? Hvordan klares de? Måske du kender en tutorial, dokumentation, ja eller navnet på den metode der?:P

Så ville jeg jo nok over i klasser og objekter. Skitse:

  function ns(vv) { this.v=vv; }
  ns.prototype.v=0;
  ns.prototype.q = function () { alert("f1: "+this.v); }
  ns.prototype.z = function () { alert("f2"); }

  n=new ns(889);
  n.q(); n.z();

Same deal:

var myNamespace = {
  variabel1: 123,
  variabel2: 'Hejsa',
  somethingOtherFunction: function(pet) {
      alert("du elsker din "+pet);
  },
  initialize: function () {
      somethingOtherFunction("hund");
  }
};

e.g.

var myNamespace = {
  dyr: '(ingen)',
  somethingOtherFunction: function(pet) {
      this.dyr = pet;
      alert("du elsker din "+this.dyr);
  },
  initialize: function () {
      somethingOtherFunction("hund");
  }
};

Problemet med et "namespace" er, at du kun har eet af slagsen. Fint nok til en liste af funktioner og "globale" variabler.

jeg kan bare ikke se idéen i det der prototype library eftersom du bare kan gøre noget lignende:

function animalLikers() {
this.pet = null;

this.tellMe = function() {
  alert("du kan lide din "+this.pet);
}

this.initialize = function(pet) {
  this.pet = pet;
  this.tellMe();
}
};

var myApp = new animalLikers();
window.onload = function() { myApp.initialize("hund"); };

hvordan ****** får i lavet mere end et mellemrum i jeres kode? selvom jeg laver 2 mellemrum, laver den det bare om til ét.

coderdk > ja, det kan jeg selvfølgelig godt se. Men som jeg sagde, jeg leder bare efter et eller andet i den dur (også af det eksempel jeg senest har givet her i tråden) at bruge og gøre mig fortrolig med.

Det er korrekt, Chris. Prototype-metoden tilføjer til en eksisterende klasse, som man måske ikke har koden til, eller hvis man definerer klassen af flere omgange.

Ja, det kan jeg godt se, Erik, jeg kan bare ikke forestille mig et scenarie hvor det ville være mere anvendeligt.

Du kan udvide den indbyggede String: http://www.javascriptkit.com/javatutors/proto4.shtml

Jeg kan bare ikke se hvad forskellen er på det, og at smide skriv-baglæns funktionen ind i (eksempel) animalLikers ... så har alle objekterne der bliver lavet også funktionen. For mig at se, er det præcis det samme, med undtagelsen af måden det skrives på. Plus at du er nød til at have en extension for at bruge prototype.
Men vær sød at fortælle mig anderledes, hvis jeg er galt på den.

Hvis du gerne vil have alle string-objekter til at have skrivbaglæns-funktionen, så skal du gøre det som i linket - du kan jo ikke gå ind i den oprindelige string-klasse.

Ret forenklet: Objektorienteret programmering antager man ved alt når man definerer klassen. Aspect-oriented programming tilføjer metoder efterhånden som man opdager, man har brug for dem. (...hehe, grov forenkling...)

ja, men du kan jo altid ændre i en OOP-klasse, og så er der jo ikke rigtig nogen fordel i AOP?

Vi kan også skrive alt som maskinkode. Jeg tror vi er på afveje fra dit spørgsmål ... om du definerer klasser og metoder på "din" måde, eller på "min" er ligemeget lige nu.

<ole>

Fordelen ved prototyping er bl.a, at du kan skrive et library, indeholdende et objekt med de properties og metoder, som du bruger i næsten alle de applikationer, du sædvanligvis arbejder med.

Derefter kan du extend'e objektet i flere forskellige versioner - målrettet specielle applikations typer, du veksler mellem at skrive - men stadig have dit core-library intakt.

Ja, man kan altid ændre i en OOP-klasse - men det er langtfra altid ønskeligt  ;o)

/mvh
</bole>

Jeg sidder og forestiller mig lidt, at en sådan "wonder-extension" som nogen af jer vidst synes prototype er, må bruge, hvis ikke mange, så en smule resourcer, som så vil gøre applikationen den smule langsomere at indlæse...
Er det så få ekstra resourcer den forbruger, eller kan det faktisk mærkes når det er store - altså virkeligt store applikationer der kører ved hjælp af prototype?

Så lukker jeg også bare denne tråd:)

Jeg kom tilfældigt tilbage forbi denne tråd og er nødt til at tilføje noget. I din kommentar (11/09-2008 12:10:19) tager du fundamentalt fejl. Den mest effektive metode er:

function MyObj(){};
var p = MyObj.prototype;
p.myProp = "Noget et eller andet";
p.add = function(bla) {
  // Kode
}
p.remove = function() {
  // Kode
}

Årsagen er, at når du definerer metoder og properties inde i constructor funktionen, indeholder hver enkelt instans disse metoder og properties - med alt, hvad det fylder i hukommelsen.

I den version, jeg har skrevet ovenfor, ligger alle metoder og propeties derimod på 'klassens' prototype - som hver instans ikke indeholder, men refererer til. Resultatet er betydelig bedre performance  ;o)

Prøv f.eks. denne her (og Erik burde faktisk også prøve):

<script type="text/javascript">
function MyObj() {
    this.method_A = function(bla) {
        return (bla*1200) - Math.round(bla+390);
    }
    this.method_B = function(bla) {
        return Math.round(bla+390) - (bla*1200);
    }
}


function MyObj2(){};
var p = MyObj2.prototype;
p.method_A = function(bla) {
    return (bla*1200) - Math.round(bla+390);
}
p.method_B = function(bla) {
    return Math.round(bla+390) - (bla*1200);
}

function foo() {
    var oStart = new Date();
    for (var i=0; i<200000; i++) new MyObj();
    alert(new Date().getTime() - oStart.getTime());
}

function fooBar() {
    var oStart = new Date();
    for (var i=0; i<200000; i++) new MyObj2();
    alert(new Date().getTime() - oStart.getTime());
}
</script>

<button onclick="foo()">Uden prototype</button>
<button onclick="fooBar()">Med prototype</button>

I alle browsere, jeg har testet med, er der markant forskel ... så nej, det er ikke helt ligemeget, hvilken version man benytter  ;o)

- og du kan naturligvis også skrive:

function MyObj2(){};
MyObj2.prototype = {
    method_A: function(bla) {
        return (bla*1200) - Math.round(bla+390);
    },
    method_B: function(bla) {
        return Math.round(bla+390) - (bla*1200);
    }
}

- som performer ligeså godt. Prototypen med alle dens metoder og propeties oprettes én gang. Derefter refererer alle instanser til denne prototype - scoped til instansen

Det er jo smart :)

Det har jeg sandelig heller ikke prøvet at skjule  ;o)

Skæg for sig og snot for sig:
Der bliver skrevet masser af mere eller mindre tvivlsomme JS-libraries i disse år. Desværre bliver de ofte skrevet (og extended) af folk, der ikke har nok viden og/eller ikke er tilstrækkeligt nysgerrige til at teste og undersøge forskellige scenarier og konstruktioner.

Derfor synes jeg, det betaler sig at bruge lidt tid på at forklare disse to forskellige måder at konstruere objektinstanser på - og vise, hvor stor forskel, der kan være - og at forskellen ikke nødvendigvis peger i den retning, man tror.

Dette er blot et enkelt af rigtig mange eksempler, som man bør undersøge, når man laver store og komplekse libraries. Man bør altid insistere på at kende/undersøge konsekvenserne af (og begrundelserne for) _alle_ de ting, man gør i en kodeeditor.

Moden går desværre i en anden retning, så mange skriver skodscripts, mens de er betydeligt mere optaget af ligegyldigheder - f.eks. af XHTML, som p.gr.a. manglende understøttelse ikke kan bruges til noget særligt de kommende år - eller af endelig ikke at komme til at nævne, man engang har brugt en tabel i et HTML-dokument ... uden efterfølgende at skrifte  ;o)