SELFHTML aktuell  Artikel  Javascript  UTF-8 und base64
	Performance in Javascript
	Performanceprobleme  Die Arbeitsweise mit Arrays

Performanceprobleme

JavaScript ist, wie der Name schon sagt, eine Scriptsprache mit all ihren Vorteilen. Sie läuft auf verschiedenen Rechnerarchitekturen mit verschiedenen Betriebssystemen. Wo Licht ist, ist jedoch auch Schatten, und der Schatten präsentiert sich in Form von mäßiger Performance. Scriptsprachen können nicht explizit auf die Harware zugreifen, so wie kompilierte Programme. Somit sind sie auf die Performance des Script-Interpreters angeweisen. Im Fall von JavaScript ist diese nicht nur gering, sondern abhängig von Plattform und Browser auch noch sehr unterschiedlich. Dies liegt zum Teil im Ursprung von JavaScript begründet. Zweck der Sprache ist es nicht, seitenweise Text zu bearbeiten, sondern dem Programmierer ein Mittel zum Abfangen von Nutzereingaben in die Hand zu geben.
Deshalb ist die UTF-8 Codierung und die anschließend vorgestellte base64-Konvertierung prinzipiell als Zweckentfremdung von JavaScript zu sehen, und wir müssen uns selber Gedanken machen, wie wir den Code so effizient wie möglich gestalten.
Auf der letzten Seite des Artikels ist ein Encoder/Decoder implementiert, welcher alle Konvertierungen vornimmt und für jeden Schritt die Zeit misst. Hier können Sie sich ein Bild davon machen, ob die Performance Ihren Ansprüchen genügt oder nicht. Im folgenden geht es um eine Methode, die Übergabe der Daten von der UTF-8-Funktion zur base64-Funktion zu beschleunigen, indem auf eine Rückumwandlung in Strings verzichtet wird.

Die Arbeitsweise mit Arrays

Wie angesprochen ist die Verwendung von Strings zur Übergabe der Werte zwischen den Funktionen nicht sehr performant und vor allem unter Netscape 4.x recht anfällig. Deshalb ist es sinnvoller, besonders dann, wenn UTF-8 zusammen mit base64 eingesetzt wird, die Datenübergabe array-basiert stattfinden zu lassen. Hier sind die UTF-8 Quelltexte, die das ermöglichen. Bitte lesen Sie die Erklärung unterhalb der Tabellen.

UTF-8-Encodierer und Decodierer mit arraybasierter Datenübergabe

00:        /* -------------------- encoder ------------------------- */
01:         function encode_utf8(rohtext) {
02:             // dient der Normalisierung des Zeilenumbruchs
03:             rohtext = rohtext.replace(/\r\n/g,"\n");
04:             var d=[];
05:             for(var n=0; n<t.length; n++)
06:                 {
07:                 var c=t.charCodeAt(n);
08:                 // all the signs of ansi => 1byte
09:                 if (c<128)
10:                     d[d.length]= c;
11:                 // all the signs between 127 and 2047 => 2byte
12:                 else if((c>127) && (c<2048)) {
13:                     d[d.length]= ((c>>6)|192);
14:                     d[d.length]= ((c&63)|128);}
15:                 // all the signs between 2048 and 66536 => 3byte
16:                 else {
17:                     d[d.length]= ((c>>12)|224);
18:                     d[d.length]= (((c>>6)&63)|128);
19:                     d[d.length]= ((c&63)|128);}
20:                 }
21:             return d;
22:             }

UTF-8-Decodierer und Decodierer mit arraybasierter Datenübergabe

23:         /* -------------------- decoder ------------------------- */
24:         function decode_utf8d2t(d)
25:             {
26:             var r=[]; var i=0;
27:             while(i<d.length)
28:                 {
29:                 if (d[i]<128) {
30:                     r[r.length]= String.fromCharCode(d[i]); i++;}
31:                 else if((d[i]>191) && (d[i]<224)) {
32:                     r[r.length]= String.fromCharCode(((d[i]&31)<<6) | (d[i+1]&63)); i+=2;}
33:                 else {
34:                     r[r.length]= String.fromCharCode(((d[i]&15)<<12) | ((d[i+1]&63)<<6) | (d[i+2]&63)); i+=3;}
35:                 }
36:             return r.join("");
37:             }
38:

Erläuterung:

Javascript unterstützt die Übergabe von Arrays an Unterfunktionen. Somit müssen die übergebenen Parameter in der Funktion nicht erst geparst werden. Die Verwendung des Arrays in der Decodierfunktion scheint auf den ersten Blick unsinnig. Nach mehreren Versuchen mit größeren Texten auf verschiedenen Systemen bin ich jedoch zur Überzeugung gekommen, dass diese Version schneller ist. Ermöglicht wird das durch die join()-Funktion für Arrays, welche sehr schnell arbeitet (im Gegensatz zur concat()-Funktion zum Beispiel).
Manchmal führt die Verwendung großer Arrays zu Problemen auf Sytemen mit geringem Arbeitsspeicher. Deshalb muss abgewogen werden, was besser ist. Solange die Textmenge 10 kByte nicht übersteigt, sind diese Überlegungen eher theoretischer Natur. Das Speicherproblem liegt darin begründet, dass ein Buchstabe ein String ist. Er belegt pro Zeichen 8bit im Speicher. Eine Zahl jedoch wird als 32-bit Integer abgelegt und benötigt dadurch 4 mal soviel Speicher. Doch wie gesagt, bei kleineren Textmengen ist das nicht von Bedeutung. Aufgrund von Performance und Robustheit würde ich die Array-Variante bevorzugen. Deshalb sind die base64-Routinen so gebaut, dass sie Arrays als übergebene Parameter erwarten.

 SELFHTML aktuell  Artikel  Javascript  UTF-8 und base64

© 2007  Impressum
© 2000-2005  tobias@justdreams.de für den Text auf dieser Seite