Stil mit {stil}

Okt 2008

Methoden von Objekten

Methoden benutzen Klammern wie Funktionen und werden auch tatsächlich als Funktionen innerhalb eines Objekts realisiert. Anders als bei Unterfunktionen in Standard-Funktionen, die außerhalb der Funktion nicht sichtbar sind, kann auf die Methoden eines Objekts außerhalb des Objekts zugegriffen werden – und zwar wie bei den Eigenschaften durch die Punkt-Notation:

function Mitarbeiter(persNr) {
   this.persNr    = persNr;
   …
   this.getAge = function()
   {
      var mydate = new Date();
      return (mydate.getFullYear() - parseInt(this.persNr.substring(2,6)));
   }  
}

var mitarb = new Mitarbeiter('011954111222333');
var alter = mitarb.getAge();
alert ("Alter " + alter);

Genauso wie bei Eigenschaften von Objekten, die öffentlich (durch die Notation this.xxx) oder privat (durch das Schlüsselwort var) deklariert sein können, gibt es öffentliche und private Methode in Objekten.

Die dot-Notation

Eigenschaften und Methoden werden durch die dot-Notation angesprochen: Vorn steht das Objekt, gefolgt von einem Punkt gefolgt von einer Methode oder Eigenschaft. So entsteht ein Pfad von einem Objekt zu einer Methode oder einer Eigenschaft, und da Eigenschaften selber wieder Objekte sein können, kann dieser Pfad auch tief werden.

var mitarbeiter = {
   persNr    : 0119601234,
   lastName  : "Meier",
   adress    : {
      ort  : "Neukirchen",
      plz  : 47110
   }
}
alert(mitarbeiter.adress.plz);

Auf die ersten drei Buchstaben von mitarbeiter.adress.ort greift z.B. substring wie folgt zu

var short = mitarbeiter.adress.ort.substring(0,3);

Die dot-Notation ist nur eine Technik, um an eine Eigenschaft oder Methode zu gelangen. Stattdessen könnte auch ein Array benutzt werden, das mit eckigen Klammern und einem Index auf Element zugreift. Diese Anweisungen sind semantisch äquivalent:

Über die Schlüssel eines Objekts kann iteriert werden:

var mitarbeiter = { persNr: 0119601234, lastName: "Meier" }
for (var attr in mitarbeiter) {
   alert (attr + ' = ' + mitarbeiter[attr]);
}

Für Arrays sollte diese Iteration allerdings niemals benutzt werden – für Arrays gibt es eigene Techniken der Iteration.

Privilegierte Methoden

Privilegierte Methoden können auf private Variablen und Methoden zugreifen und sind selber für public-Methoden und außerhalb des Objekts zugreifbar. Privilegierte Methoden können gelöscht oder ersetzt werden, aber sie können nicht geändert oder gezwungen werden, ihre Geheimnisse preis zu geben.

privilegierte Methoden werden durch this im Konstruktor zugewiesen.

function Adress (firstName, lastName, city) {
   this.firstName = firstName; 
	this.lastName  = lastName;
	this.city      = city; 
	var passwort   = "geheim";
	var self       = this; 
   
   function checkPasswort {
   	if (self.firstName == "Ulrike") {
   	   return passwort;
   	} else {
   	   return null;
   	}
   }
   
   this.decodePasswort = function () {
   	if (checkPasswort()) {
   	   return self.passwort;
   	} else {
   		return null;
   	}
   }
}

decodePasswort ist eine privilegierte Methode. Der Aufruf von adressA.decodePasswort() gibt "geheim" zurück, wenn adressA("Ulrike").decodePassword() mit "Ulrike" aufgerufen wird und null sonst.

Muster von public, private und privileged

Public

function Constructor( ... ) 
{
   this.membername = value;
}
Constructor.prototype.membername = value;

Private

function Constructor( ... )
{
   var self = this;
   var membername = value; 
   
   var membername = function membername( ... ) {
      ... 
   }
}

Privileged

function Constructor( ... ) 
{
   this.membername = function( ... ) {
      ... 
   }
}

Das Muster von public, private und privileged wird durch JavaScript-Closures ermöglicht. Closures sorgen dafür, dass eine innere Funktion immer Zugriff auf die Variablen und Parameter der äußeren Funktion hat, selbst nachdem die äußere Funktion zurückgegeben wurde (returned). Dieser Mechanismus ist ein mächtiges Werkzeug, wird aber selten erwähnt.

Simon Willison Closures and executing JavaScript on page load

Prototypen

Wenn ein Mitglied eines Objekts gesucht und nicht im Objekt selber gefunden wird, holt ihn JavaScript aus den Prototypmitgliedern des Objekt-Konstruktors. Um eine Methode zu einem Objekt, das als Konstruktor angelegt wurde, hinzuzufügen, deklariert man eine Funktion zum Prototypen des Konstruktors:

function Simple() 
{
...
}

Simple.prototype = new Extended();
Simple.prototype.action = function() {};

Eine Methode toString, um den Inhalt des Objekts auszugeben:

function Mitarbeiter(persNr, firstName, lastName) 
{
   this.persNr    = persNr;
   …
   this.getAge = function()
   {
      var mydate = new Date();
      return (mydate.getFullYear() - parseInt(this.persNr.substring(2,6)));
   }  
}

Mitarbeiter.prototype.toString = function() {
	return this.persNur + " " + this.firstName + " " + this.getAge();
}

…
alert (Mitarbeiter)

Prototypen stellen eine Form von Vererbung zur Verfügung.

Die Javascript-Objekt-Klasse wird automatisch an jedes Objekt vererbt. Die Methoden der Objekt-Klasse werden von allen Objekten in Javascript unterstützt.

Die Eigenschaft prototype stellt die Basis der Vererbung dar. Wenn eine Eigenschaft oder Methode eines Objekts gesucht wird und nicht bei der Objekt-Instanz selber gefunden wird, wird beim Prototyp des Objekts gesucht. Da prototype genauso wie alles andere in Javascript ein Objekt ist, hat die Klasse des Prototyps selber einen Prototyp.

Wenn ein Prototyp oder eine Methode in einer Objektinstanz oder ihrem Prototypen nicht gefunden wird, geht Javascript weiter zum Prototyp des Prototypes usw., bis die Objektklasse selber erreicht wird.