DOM: Javascript vs. C++

Musste das Syntax-Highlighting wegmachen, das hat das Layout zerstört

Ich geh gerade mal sterben. Beide Funktionen haben dieselbe Funktionalität, nämlich alles Bilder innerhalb einer Webseite zu “verstecken”. Hier der Javascript-Code

function RemoveImages(doc) {
  var images = doc.images;
    if (images != null) {
      for (var i = 0; i < images.length; i++) {
        var img = images.item(i);
        img.style.display = "none";
      }
    }
}

weiterlesen

Javascript: getter und setter

Nix spektakuläres, bin ich gerade rübergestolpert. Nachdem ich mich ja schon über Sichtbarkeit ausgelassen habe, kommt jetzt der Trick wie man getter und setter definiert.

Bisher hab ich das immer so gemacht:

function Field(val){
    /** @private */
    var value = val;

    /** @public*/
    this.getValue = function(){
        return value;
    };

    /** @public*/
    this.setValue = function(val){
        value = val;
    };
}

Ist auch wunderbar, allerdings bissle lästig das immer zu schreiben. Deshalb hier das ganze im “Mozilla Style”:

function Field(val){
    var value = val;

    this.__defineGetter__("value", function(){
        return value;
    });

    this.__defineSetter__("value", function(val){
        value = val;
    });
}

Potthässlich in der Tat, aber macht genau dasselbe wie der Code drüber. Wenn man jetzt ignoriert das “value” umbedingt private sein muss, dann sieht das sogar “schön” aus:

function Field(val){
    this.value = val;
}

Field.prototype = {
    get value(){
        return this._value;
    },
    set value(val){
        this._value = val;
    }
};

Bringt mir jetzt nicht so besonders viel, aber vielleicht brauchts ja jemand anders.

Links:

jQuery, Tooltip, show() und hide()

Nunja, endlich hab ich das Problem gelöst das ich hatte. Schön wenn man auf Banalitäten hingewiesen werden muss …

var _PendingHideLink;
var _PendingHideDiv;
$("#someDivId").hover(function() {
    if (_PendingHideLink) {
        clearTimeout(_PendingHideLink);
    }
    if (_PendingHideDiv) {
        clearTimeout(_PendingHideDiv);
    }
}, function() {
    _PendingHideDiv = setTimeout(function() {
        $("#someDivId").hide();
    }, 2000);
});
$(".someLinks").hover(function(e) {
    $("#someDivId").show();
}, function() {
    _PendingHideLink = setTimeout(function() {
                $("#someDivId").hide();
            }, 5000);
});

Das macht: Beim positionieren des Mauszeigers übern einen Link (“mouseover”) mit der Klasse “someLinks” wird das div mit der Id “someDivId” eingeblendet und nach 5 Sekunden wieder ausgeblendet. AUSSER man geht auf das eingeblendete div, dann bleibts offen, solange bis man das div wieder verlässt (“mouseout”). Dazu sollte man noch wissen das jQuery “hover” als Kombination versteht ($().hover == ($().mouseover; $().mouseout;)). Nunja, UND man sollte wissen das setTimeout eine Id zurückliefert die man mit “clearTimeout” wiederverwenden kann

MochiTest-Lite

Just a reminder to myself, because I want to try that extension:

Mochitest is a unit testing framework created by contributors to Mozilla projects. Mochitest is based on MochiKit , the incredibly useful Javascript library. MochiKit as the basis for writing unit tests has been proven very useful to developing Mozilla applications because of the thick layers of Javscript code in applications like Firefox.

What then, is Mochitest-Lite?
Mochitest, as it is used at Mozilla, requires Python to drive the command line interface, and automate the testing. Python is a very powerful tool for this purpose because, along with automation, it can overwrite and then rewrite configuration files like manifests and preferences, all while having a minimal impact on the application being tested. Mochitest also uses a client-server architecture to serve test documents to the application being tested. On top of that, an application needs to be built with the Mozilla build system to work with Mochitest.

This makes sense for large applications like Firefox, but what about a unit testing framework for developers of small XULrunner applications and extensions for existing Mozilla applications? These developers have different requirements. Mochitest-Lite is a way to get the same test writing tools and automation without the overhead of running Mochitest the same way it is used to test Mozilla code.

Vererbung in Javascript anhand von Exceptions

Hab noch zwei weitere Artikel gefunden, beide englisch:

Jop, ein weiterer Artikel zu Javascript. Und zur “komischen” Vererbung von Javascript.

Jeder Programmierer kennt Exceptions, diese netten Fehler die einen an den Kopf geschmissen werden, wenn was schief läuft. Auch sowas gibts bei Javascript:

try {
  doSomething();
} catch(e) {
  alert(e.toString());
}

Klassisches try/catch-Statement. Demnächst muss ich nochmal nachschauen wie man “verschiedene” Exceptions erkennt und dann getrennt behandelt. Nunja, weiter gehts, wir bauen uns eine Exception:

throw 42;
throw "I'm a string";
throw {toString: function() { return "I'm an object!"; } };

Alles wunderbar, aber String-Nachrichten schmeissen kann ja jeder. Kommen wir also zu der “BaseException”:

function BaseException(_message) {
	this.name = "BaseException";
	this.message = _message;
}
BaseException.prototype = {
	name : null,
	message : null,
	toString : function() {
		return this.name + ': "' + this.message + '"';
	}
}

Erstmal was ganz simples. Kann man z.B. so schmeissen und fangen:

try {
  throw new BaseException("foobar");
} catch (e) {
  alert(e.toString()); // alerts: "BaseException: foobar"
}

Schön, nicht wahr? Jetzt brauchen wir noch Vererbung:

// ripped from http://www.sitepoint.com/blogs/2006/01/17/javascript-inheritance/ 
function extend(descendant, parent) {
	var sConstructor = parent.toString();
	var aMatch = sConstructor.match(/\s*function (.*)\(/);
	if (aMatch != null) {
		descendant.prototype[aMatch[1]] = parent;
	}
	for (var m in parent.prototype) {
		descendant.prototype[m] = parent.prototype[m];
	}
};

Dies ist wohl leider notwendig. Diese “extend”-Function macht das irgendwie wohl cross-browser-kompatibel. Nunja, für Mozilla-only geht es auch anders. Nunja, “geerbt” wird jetzt so:

function OtherException(_message) {
	// call "super" constructor
	this.BaseException(_message);
	this.name = "OtherException";
}
// OtherException inherits from BaseException
extend(OtherException, BaseException);

Voilà. Fertig ist das Butterbrot:

try {
  throw new BaseException("foobar");
} catch (e) {
  alert(e.toString()); // alerts: "BaseException: foobar"
}
try {
  throw new OtherException("foobar");
} catch (e) {
  alert(e.toString()); // alerts: "OtherException: foobar"
}

Eclipse, Subversion und Spket

Die drei Sachen verwende ich gerade. Da aber irgendwie gerade was abschmiert, steige ich mal auf “unstable” (aka 3.5M3)um:

http://download.eclipse.org/eclipse/downloads/

Eclipse Update URLs:

public, private und “privileged” in Javascript

Jetzt wirds hässlich. Natürlich gibts “public” und “private” auch in Javascript. Allerdings, wie immer, ein bisschen anders:
Public

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

myConst = new Constructor("foobar");
print myConst.membername; // prints 'foobar'

Private

function Constructor(value) {
    var self = this;
    this.membername1 = value; // public member
    var membername2 = value + "private"; // private member
    function membername() { // private method
        print self.member; //access to public member in private method
        print membername2; // access to private member in private method
    }
}

myConst = new Constructor("foobar");
print myConst.membername1; // prints 'foobar'
print myConst.membername2; // prints 'undefined'
myConst.membername(); //no such function

Wenn man jetzt aber z.B. mittels dem property “prototype” auf private-members zugreifen will, dann wird man scheitern. “public” hat keinen Zugriff auf “private”. Dazu muss man die “privileged”-Methoden verwenden.

Privileged

function Constructor(value) {
    this.membername = function membername() {
        print "hi";
    };
}

myConst = new Constructor("foobar");
myConst.membername(); // prints "hi"

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 ;)