Stil mit {stil}

Okt 2007

Methoden von Strings

Javascript bietet Funktionen für das Suchen und Ersetzen von Zeichen in Strings, kann Strings splitten und Zeichenketten aus Strings extrahieren und die Position von Zeichen innerhalb eines Strings bestimmen.

Zum besseren Verständnis der String-Methoden hilft es, sich den String als ein besonderes Array vorzustellen:

                                     1 1 1 1 1 1 1 1 1 1 2 2 2 2 2
Index-Position   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 
Zeichen          I c h   b i n   e i n e   Z e i c h e n k e t t e

charAt()

Zeichen an der eingegebenen Position – gezählt ab 0.

         // 0123456789012345678901234
var elem = "Ich bin eine Zeichenkette";
alert(elem.charAt(5));                                   // Ausgabe: i

charCodeAt(z)

Unicode-Codewert an der Position z.

         // 012345678901234567890
var elem = "Ich bin der Schlüssel";
alert(elem.charAt(16) +  " " + elem.charCodeAt(16));     // Ausgabe: 252

Jedes Zeichen hat eine bestimmte Position in der Unicode-Codetabelle. alert(charAt(16) + " " + elem.charCodeAt(16)); gibt das Zeichen und im Anschuss daran den Codewert des Zeichens aus.

concat(str)

Zeichenkette str anhängen.

var vorname = "Egon";
var name = vorname.concat(" Meier");

alert(name);                                      // Ausgabe: Egon Meier

fromCharCode(c1,c2,..)

Zeichenkette aus Unicode-Werten ci erzeugen.

var simpleString = String.fromCharCode(69, 103, 111, 110);

alert(simpleString);                               // Ausgabe: Egon

indexOf( )

ermittelt die erste Position einer Zeichenkette innerhalb einer Zeichenkette. Liefert -1, wenn die Zeichenkette nicht gefunden wird.

                 // 0123456789012345678901234
var simpleString = "Ich bin eine Zeichenkette";

alert(simpleString.indexOf('eine'));               // gibt 8 aus

lastIndexOf( )

letzte Position einer Zeichenkette. Liefert -1, wenn die Zeichenkette nicht gefunden wird.

                 // 0123456789012345678901234567890123456
var simpleString = "http://www.wisotop.de/jsStrings.shtml";
alert(simpleString.lastIndexOf('/'));              // Ausgabe: 21

match()

Durchsucht eine Zeichenkette mit einem regulären Ausdruck.

var simpleString = "Paul Pauline Apostel Paulus Paulinengärtchen Paul Paulatius";
var treffer = 0;

if (simpleString.match(/Paul/g)) {
   treffer = simpleString.match(/Paul/g).length;
}
alert(treffer);                                   // Ausgabe: 6 

/Paul/g ist ein regulärer Ausdruck, der nach allen Vorkommen der Zeichenfolge Paul sucht. Damit es nicht zu einem Fehler kommt, wenn der gesuchte Begriff nicht in der Zeichenkette simpleString vorkomment, initialisiert var treffer = 0; die Variable treffer.

Wenn die Zeichenfolge gefunden wird, gibt simpleString.match(/Paul/g) gibt ein Array aller Treffer zurück, also ist die Anzahl der Treffer die Länge der Arrays: simpleString.match(/Paul/g).length;.

Die Methode match() funktioniert auch mit einem gewöhnlichen String.

var treffer = simpleString.match('Paul').length;
alert (treffer);                                   // gibt 1 aus

Die Suche nach einem einfachen String gibt den ersten Treffer zurück, falls das Suchmuster gefunden wird.

replace(a,b)

Suchen und Ersetzen mit einem regulären Ausdruck. Sucht Text a und ersetzt ihn durch Text b.

var simpleString = "Paul Pauline Apostel Paulus Paulinengärtchen Paul Paulatius";
var newString = simpleString.replace(/Paul/g, 'xxxx');
alert(newString);

// Zeigt an:	
// xxxx xxxxine Apostel xxxxus xxxxinengärtchen xxxx xxxxatius

simpleString.replace(/Paul/g, 'xxxx') sucht nach allen Vorkommen von Paul, ersetzt die Treffer durch die Zeichenfolge xxxx und weist das Ergebnis der string-Variablen newString zu.

Die Methode replace() funktioniert auch mit einem gewöhnlichen String.

var newString = simpleString.replace('Paul', 'xxxx');
alert(newString);

// Zeigt an:
// xxxx Pauline Apostel Paulus Paulinengärtchen Paul Paulatius

Suchen und Ersetzen mit einem einfachen String ersetzt das erste Vorkommen des Suchstrings.

search(a)

Sucht die Position der Zeichenkette a. Gibt 1 zurück, wenn die Zeichenkette gefunden wird und -1 sonst.

                    0123456789012345678901234567890123456
var simpleString = "Paul Pauline Apostel Paulus Postpaket";
var treffer = simpleString.slice(/Post/i);
alert(treffer);                          // gibt 14 aus

simpleString.search(/Post/i) sucht das erste Vorkommen des Strings Post (und zwar unabhängig von Groß-/Kleinschreibung durch den Modifier i des regulären Ausdrucks) und weist das Ergebnis der Variablen treffer zu.

search() kann auch mit einem gewöhnlichen String aufgerufen werden.

var treffer = simpleString.search('Post');
alert(treffer);                          // gibt 28 aus

Da es bei einem einfachen String keine Möglichkeit gibt, die Suche unabhängig von der Klein-/Großschreibung des Begriffs durchzuführen, findet search() die gesuchte Zeichenfolge erst an Position 28.

slice(v,b)

Teil aus einer Zeichenkette extrahieren. Im Argument stehen v = von (inklusive), b = bis(exklusive).

                    0123456789012345678901234567890123456
var simpleString = "Paul Pauline Apostel Paulus Postpaket";
var ausschnitt = simpleString.slice(13, 20);
alert(ausschnitt);                      // gibt Apostel aus

simpleString.slice(13, 20) schneidet die Zeichenfalge beginnend bei Position 13 bis inklusive Position 19 aus und weist die Zeichenfolge der Variablen ausschnitt zu.

split(a [,n])

teilt eine Zeichenkette bei jedem Vorkommen des Teilstrings oder regulären Ausdrucks a und speichert die Fragmente in einem Array. Der optionale Parameter n gibt die maximale Anzahl von Feldern an, die von der Methode erzeugt werden sollen.

var simpleString = "Paul, Pauline, Apostel, Paulus, Postpaket";
var felder = simpleString.split(',', 3);
var text = "";
for (var i=0; i<felder.length; i++) {
	text +=  felder[i] + "\n";
}
alert(text);

// gibt aus
// Paul
//  Pauline
//  Apostel

simpleString.split(',') splittet den String anhand des »,«-Zeichens auf und speichert die ersten drei Fragmente in jeweils einem Feld des Arrays felder. Die for-Anweisung durchläuft alle Felder des Arrays und schreibt die Werte in einen Textstring für die Ausgabe.

substr(v,z)

ermittelt ein Fragment Zeichenkette ab Position v (inklusive) mit einer Länge von z Zeichen.

                    0123456789012345678901
var simpleString = "http://www.wisotop.de/";
var fragment = simpleString.substr(11, 7);
	
alert(fragment);                         // gibt wisotop aus

var fragment = simpleString.substr(11, simpleString.length); erzeugt ein Fragment des Strings simpleString ab Position 11 mit einer Länge von 7 Zeichen.

substring (v,b)

schneidet ein Fragment ab Position v (inklusive) bis zur Position b (exklusive) aus einem String.

var simpleString = "http://www.wisotop.de/";
var fragment = simpleString.substring(11, 18);
	
alert(fragment);                        // gibt wisotop aus

var fragment = simpleString.substring(11, 18); schneidet ein Fragment ab Position 11 bis Position 18 aus der Zeichenfolge simpleString.

Zeigen

String-Methoden zur Textformatierung

Methode	Beschreibung	Beispiel
anchor( )	erzeugt einen Anker. Argumente sind Sprungadresse, Markenname.	obj.anchor("hier her");
big( )	größerer Text	obj.big();
blink( )	Blinkender Text	obj.blink();
bold( )	fetter Text	obj.bold();
fixed( )	Schreibmaschinenschrift	obj.fixed();
fontcolor( )	Textfarbe	obj.fontcolor("red");
fontsize( )	Schriftgröße von 1 bis 7	obj.fontsize(6);
italics( )	Kursivschrift	obj.italics();
link( )	Link erstellen, URL ist Argument	obj.link();
small( )	kleinere Schrift	obj.small();
strike( )	durchgestrichen	obj.strike();
sub( )	tief gestellter Text	"normal" +obj.sub();
sup( )	hoch gestellter Text	"normal" +obj.sup();
toLowerCase( )	konvertieren in Kleinbuchstaben	obj.toLowerCase();
toUpperCase( )	konvertieren in Großbuchstaben	obj.toUpperCase();

String-Konstruktor

Strings können nicht nur durch die Zuweisung eines String-Literals an einen Variablennamen definiert werden, sondern auch durch den String-Konstruktor.

var objectString = new String('Hallo Welt!');   // String-Konstruktor
var objectString = new String('');              // String-Konstruktor

Allerdings ist die literale Notation der Normalfall und der String-Konstruktor bleib eher besonderen Anwendungen vorbehalten.

String ist der Prototyp für Zeichenketten und wickelt sich um den primitiven Datentyp string. Wrapper sind Objekte, die denselben Namen haben wie der Datentyp, den sie darstellen. Für jeden primitiven Datentyp – string, number und boolean – gibt es ein String-Objekt, ein Number-Objekt bzw. ein Boolean-Objekt. Wrapper stellen die Eigenschaften und Methoden, die für das Objekt definiert sind, dem primitiven Datentyp zur Verfügung und so können primitive Strings als Objekte behandelt werden.

var simpleString = 'Hallo Welt!';                // Literale Notation
var objectString = new String('Hallo Welt!');    // String-Konstruktor

Alle Methoden des String-Objekts (z.B. String.length) können mit dem literalen Wert benutzt werden, weil JavaScript automatisch den literalen String in ein temporäres String-Objekt umwandelt, die Methode aufruft und dann das temporäre String-Objekt löscht.

Die erste Methode ist sicherlich der Normalfall, während die zweite Methode eher selten benutzt wird. Sie wird eingesetzt, wenn sicher gestellt werden soll, dass tatsächlich ein String erstellt wird oder wenn das String-Objekt durch eigene Methoden erweitert werden soll.

Alle Methoden des String-Objekts können auch auch das String-Literal angewendet werden, da Javascript ein String-Literal automatisch in ein String-Objekt umwandelt, wenn eine Methode aufgerufen wird.