Javascript-Klassen und Objekte

Habe gerade noch das hier gefunden: Class-Based vs. Prototype-Based Languages

Ich hab zwar schon hier auf einen schönen Artikel verwiesen, aber jetzt nochmal das ganze aus meinem Munde.

Javascript is Objektorientiert. Schon immer. Glaub ich. 1995 das erstmal mit Netscape veröffentlicht, sind wir inzwischen bei Javascript 1.8 angekommen (seit 18. Dezember 2007). Javascript wird übrigens von Mozilla „gemanaged“. Und Javascript ist nicht Ecmascript. Vielmehr ist Javascript ein Dialekt von Ecmascript.

Soviel dazu. Javascript implementiert ECMAScript, genauer ECMA-262, edition 3. Innerhalb davon gibt es keine „Klassen“ im eigentlichen Sinne. Viel eher werden direkt Objekte geboren.

function meinObjekt () {
    this.zahl = 1;
}

Und schon haben wir ein Objekt/Klasse mit dem Namen „meinObjekt“. Und eine Eigenschaft „zahl“ hat es auch.

var objekt = new meinObjekt();
window.alert(objekt.zahl);

Und somit kriegen wir ein Fenster mit einer „1“ drinnen. Es gibt auch private und öffentliche Eigenschaften/Methoden, allerdings ist Javascript da etwas bockig:

function meinObjekt () {
     var self = this;
 
    /** @private */
    var foobar = "private";
    var privateMethod = function () {
        window.alert(foobar  + " " + self.barfoo);
    };
 
    /** @public */
    this.barfoo = "public";
    this.public_method = function () {
        window.alert(foobar + " " + this.barfoo);
        private_method();
    };
}

Wer sich wundert was das „self“ soll, das liegt an Javascript. Während der Zugriff von öffentlichen auf private Methoden prima klappt, ist der Zugriff von privaten auf öffentliche Methoden … anders :). Hierzu wird einfach „this“ in „self“ kopiert und dann kann wie „this“ verwendet werden. Jippie.

Ich verwende den Spass gerade so:

var logger = function() {
};
logger.prototype = {
	log : function(msg) {
		console.log(this.getNow() + msg);
	},
	getNow : function() {
		return new Date();
	}
};
var foobar = new logger();
logger.log("foobar"); // prints "foobar"

Man spricht hier von „prototyp-basierter“ Objektorientierung. Interessant wirds in dem „neuen“ Standard ECMA-262, edition 4. Dort gibt es dann tatsächlich auch Klassen:

class C {
	var val // a variable property
	var large = Infinity // a variable property
	const x = 3.14 // a constant property
	function f(n) { return n+val*2 } // a method property
}

Da ja Javascript schön dynamisch ist, gibt es auch dynamische Klassen:

dynamic class C {
}
c = new C
c.x = 37 // adds a property
delete c.x // removes it again

Weiter gehts mit Vererbung, jetzt mit Schlüsselwörtern wie „extends“:

class C {
	var val
	function f(n) { return n+1 }
}
class BetterC extends C {
	var large = 123456 // new value property
	override function f(n) { return n*3 } // overridden method property
}

Es gibt auch „final“ als Schlüsselwort, eine so bezeichnete Klasse kann dann keine Kinder kriegen. Und zu guter Letzt werden auch Interfaces eingeführt. Somit wird Ecmascript und somit auch Javascript an die „normale“ Objektorientierung herangeführt. Die komplette Spezifikation des „neuen“ ECMAScripts findet sich unter:

http://www.ecmascript.org/es4/spec/overview.pdf

Javascript aus FF-Erweiterung in der Webseite benutzen

Langer Titel, kurzer Blogeintrag. Ich bastel gerade daran rum, diverse Javascript-Funktionen innerhalb der HTML-Seite zu benutzen. Das kann ziemlich hässlich werden:

var head = this.getContentDocument().getElementsByTagName("head")[0];
var script = this.getContentDocument().createElement("script");
var showImage = this.getContentDocument().createTextNode("function showImage(id) { "
		 + "var image = document.getElementById(id);"
		 + "image.style.display = \"inline\"; "
		 + "image.parentNode.previousSibling.addEventListener(\"mouseout\",
		 function() {"
		 + "window.setTimeout(fadeImage, 1500, id);"
		 + "}, false)"
		 + "}");
script.appendChild(showImage);
head.appendChild(script);

Alles doppelt escapen und so. Kein Spass. Hässlich zum Lesen. Lösung:

var head = this.getContentDocument().getElementsByTagName("head")[0];
var script = this.getContentDocument().createElement("script");
script.setAttribute("src", "resource://jslibs/foobar.js");
script.setAttribute("type", "text/javascript");
head.appendChild(script);

Nix spektakuläres, aber innerhalb der Datei „foobar.js“ kann man jetzt ‚ganz normales‘ Javascript schreiben. Ich freu mich über sowas 😉

Javascript dynamisch laden

Heute habe ich mich hauptsächlich damit beschäftigt, wie man Javascript-Dateien innerhalb von Javascript-Dateien includiert. Mein erster Ansatz war (etwas XUL-spezifisch, aber prinzipiell klappt das auch im HTML-DOM):

var jsFiles = [
    "chrome://myEntension/content/lib/domain.js",
		"chrome://myExtension/content/lib/helper.js",
    "chrome://myExtension/content/lib/js_locale.js",
		"chrome://myExtension/content/lib/urlParser.js"
    ];
var root = document.getElementById("someId")
for (var i = 0; i < jsFiles.length; i++) {
	var scriptElement = document.createElement("script");
	scriptElement.setAttribute("type", "application/x-javascript");
	scriptElement.setAttribute("src", jsFiles[i]);
  root.appendChild(scriptElement);
}

Das hat auch eigentlich soweit ganz gut geklappt, im DOM waren alle drin. Nur war irgendwie keine der includierten Funktionen … verfügbar. So als ob die Knoten in den DOM reingehängt wurden, aber das src-Attribute nicht ausgelesen und .. geparst.

Nunja, nachdem ich damit eine Weile rumgedoktert habe, wurde im im Mozilla-IRC-Channel auf Components.utils.import hingewiesen. Das ist doch genau das was ich brauche. Also sieht das jetzt so aus:

var jsFiles = [
    "chrome://myEntension/content/lib/domain.js",
		"chrome://myExtension/content/lib/helper.js",
    "chrome://myExtension/content/lib/js_locale.js",
		"chrome://myExtension/content/lib/urlParser.js"
    ];
for (var i = 0; i < jsFiles.length; i++) {
  Components.utils.import(jsFiles[i]);
}

Wunderhübsch. Klappt nur nicht, weil chrome://-URLs nicht erlaubt sind. Man braucht file:// oder resource://. Also schreibt man ins chrome.manifest:

resource jslibs content/lib/

und schreibt obige chrome://-URL um in:

"resource://jslibs/helper.js"

Wunderprächtig. Jetzt klappts. Fast. In jede Datei die man importiert muss man noch reinschreiben was denn exportiert werden soll. Klingt umständlich, der tiefere Sinn hat sich mir noch verschlossen, aber erstmal egal für die Funktionalität:

var EXPORTED_SYMBOLS = ["LOG"];
function LOG(msg) {
    Components.classes["@mozilla.org/consoleservice;1"]
            .getService(Components.interfaces.nsIConsoleService);
            .logStringMessage(new Date().toLocaleString() + ": " + msg);
}

Am obigen EXPORTED_SYMBOLS gibt man an welche Variablen nach außen hin sichtbar sein sollen. Voila, es ist geschafft.