0251 / 590 644 - 0
info@a-coding-project.de

JavaScript:  String

Das String-Objekt stellt die Grundklasse für alle Strings dar. Es enthält die Grundeigenschaften und -methoden zur Verarbeitung eines Strings.

String erstellen

Vom Prinzip her muss ein String nicht extra erstellt werden - es reicht wenn einer Variablen ein betreffender Wert zugewiesen wird. Um allerdings explizit einen String zu erstellen wird - wie bei allen Objekten - mit dem new-Operator gearbeitet. Der Aufruf String() erzeugt dann das entsprechende Objekt. Außerdem kann als Parameter ein Wert für den zu erstellenden String übergeben werden. Beispiel:

a = new String();
b = new String('mein Text');

Strings können außerdem auch direkt von der Zeichenfolge aus wie ein normales Objekt behandelt werden. Dazu wird einfach nach der durch Anführungszeichen geschlossenen Zeichenfolge der Punkt sowie die Methode bzw. Eigenschaft notiert. Beispiel:

a = 'mein String'.bold(); // = '<b>mein String</b>'

Eigenschaften

constructor

Die constructor-Eigenschaft gibt die Funktion an, die das Objekt erstellt hat.
Notation: Objekt.constructor

a = new Object();
b = a.constructor;

length

Die length-Eigenschaft gibt die Länge (Anzahl der Zeichen) eines Strings aus.
Notation: Objekt.length

a = new String('abcdefg');
b = a.length; // = 7

prototype

Die prototype-Eigenschaft gibt eine Referenz auf die eigentliche Objektklasse wieder.
Notation: Objekt.prototype

Object.prototype.Array = new Array();
a = new Object();
b = a.Array;

Methoden

anchor

Die anchor-Methode erzeugt einen Anker aus einem String und gibt diesen wieder. Als Parameter wird dazu der Name des Ankers erwartet.
Notation: Objekt.anchor(Name)

a = new String('abcdef');
b = a.anchor('anker1'); // = '<a name="anker1">abcdef</a>'

big

Die big-Methode erzeugt einen String, der als groß (eben big) gekennzeichnet ist und gibt diesen wieder.
Notation: Objekt.big()

a = new String('abcdef');
b = a.big(); // = '<big>abcdef</big>'

blink

Die blink-Methode erzeugt einen String, der als blinkend (eben blink) gekennzeichnet ist und gibt diesen wieder.
Notation: Objekt.blink()

a = new String('abcdef');
b = a.blink(); // = '<blink>abcdef</blink>'

bold

Die bold-Methode erzeugt einen String, der als fett (eben bold) gekennzeichnet ist und gibt diesen wieder.
Notation: Objekt.bold()

a = new String('abcdef');
b = a.bold(); // = '<b>abcdef</b>'

charAt

Die charAt-Methode gibt von einem String ein bestimmtes Zeichen wieder. Dazu muss der Index des Zeichens als Parameter übergeben werden. Der Index beginnt dabei bei 0 (Null) und endet bei der Länge des Strings minus 1. Wird ein Index außerhalb dieses Bereiches angegeben, so wird ein leerer String wiedergegeben.
Notation: Objekt.charAt(Index)

a = new String('abcdef');
b = a.charAt(2); // = 'c'

charCodeAt

Die charCodeAt-Methode gibt von einem String den Unicode-Wert ein bestimmten Zeichen wieder. Dazu muss der Index des Zeichens als Parameter übergeben werden. Der Index beginnt dabei bei 0 (Null) und endet bei der Länge des Strings minus 1. Wird ein Index außerhalb dieses Bereiches angegeben, so wird NaN wiedergegeben.
Notation: Objekt.charCodeAt(Index)

a = new String('abcdef');
b = a.charCodeAt(2); // = 99

concat

Die concat-Methode erzeugt einen String, der zusammengesetzt aus dem String selbst sowie weiteren Strings besteht. Als Parameter wird dazu eine beliebige Anzahl an Strings erwartet.
Notation: Objekt.concat([String1,...StringN])

a = new String('abcdef');
b = a.concat('g','h','i'); // = 'abcdefghi'

fixed

Die fixed-Methode erzeugt einen String, der als fixiert oder Teletype / Schreibmaschinentext (eben fixed) gekennzeichnet ist und gibt diesen wieder.
Notation: Objekt.fixed()

a = new String('abcdef');
b = a.fixed(); // = '<tt>abcdef</tt>'

fontcolor

Die fontcolor-Methode erzeugt einen String, der mit einer bestimmten Farbe gekennzeichnet ist und gibt diesen wieder. Als Parameter wird dazu der Farbwert erwartet.
Notation: Objekt.fontcolor(Farbe)

a = new String('abcdef');
b = a.fontcolor('#ff0000'); 
// = '<font color="#ff0000">abcdef</font>'

fontsize

Die fontsize-Methode erzeugt einen String, der mit einer bestimmten Schriftgröße gekennzeichnet ist und gibt diesen wieder. Als Parameter wird dazu die Größe erwartet.
Notation: Objekt.fontsize(Größe)

a = new String('abcdef');
b = a.fontsize(5); // = '<font size="5">abcdef</font>'

fromCharCode

Die fromCharCode-Methode erzeugt einen String, der aus bestimmten (Unicode-) Zeichen besteht. Als Parameter werden dazu eine beliebige Anzahl an Unicode-Werten der zu erstellenden Zeichen erwartet.
Notation: Objekt.fromCharCode([Wert1,...WertN] )

a = String.fromCharCode(97,98,99,100); // = 'abcd'

indexOf

Die indexOf-Methode gibt den Index eines bestimmten Strings innerhalb des aktuellen Strings wieder. Außerdem kann ein Anfangswert für die Suche nach dieser Zeichenfolge festgelegt werden. Als Parameter wird dazu die zu suchende Zeichenfolge, sowie optional der Startindex, erwartet. Wird kein passender Ausdruck gefunden, so wird der Wert -1 zurück gegeben. Wird kein Startwert angegeben, so wird automatisch am Anfang des Strings begonnen.
Notation: Objekt.indexOf(String[,Index])

a = new String('abcdefgabcdefg');
b = a.indexOf('de',8); // = 10

italics

Die italics-Methode erzeugt einen String, der als kursiv gekennzeichnet ist und gibt diesen wieder.
Notation: Objekt.italics()

a = new String('abcdef');
b = a.italics(); // = '<i>abcdef</i>'

lastIndexOf

Die lastIndexOf-Methode gibt den letzten Index eines bestimmten Strings innerhalb des aktuellen Strings wieder. Außerdem kann ein Anfangswert für die Suche nach dieser Zeichenfolge festgelegt werden. Als Parameter wird dazu die zu suchende Zeichenfolge, sowie optional der Startindex, erwartet. Wird kein passender Ausdruck gefunden, so wird der Wert -1 zurück gegeben. Wird kein Startwert angegeben, so wird automatisch am Ende des Strings begonnen.
Notation: Objekt.lastIndexOf(String[,Index])

a = new String('abcdefgabcdefg');
b = a.lastIndexOf('de'); // = 10 
c = a.lastIndexOf('de',8); // = 3

link

Die link-Methode erzeugt einen Link aus einem String und gibt diesen wieder. Als Parameter wird dazu das Ziel (href) des Links erwartet.
Notation: Objekt.link(Href)

a = new String('abcdef');
b = a.link('http://www.html-world.de'); 
// = '<a href="http://www.html-world.de">abcdef</a>'

match

Die match-Methode wendet einen regulären Ausdruck auf einen String an. Als Rückgabewert erhält man ein die gefundene Zeichenkette. Außerdem wird als Parameter der anzuwendende reguläre Ausdruck erwartet.
Notation: Objekt.match(RegExp)

a = new String('abcdef');
b = a.match(/b/ig); // = 'b'

replace

Die replace-Methode ersetzt eine Zeichenkette innerhalb eines Strings durch eine andere und gibt das Ergebnis aus. Als Parameter wird dazu die Zeichenkette oder ein regulärer Ausdruck erwartet, die/der ersetzt werden soll. Ebenso wird die Zeichenkette, die statt dessen eingesetzt werden soll erwartet. Wird kein passender Eintrag gefunden, wird nichts ersetzt.
Notation: Objekt.replace(String1,String2)

a = new String('abcdef');
b = a.replace('a','z'); // = 'zbcdef'

Außerdem können ab JavaScript 1.3 und JScript 5.5 bestimmte (Sonder)Zeichenfolgen beim Einfügen verwendet werden:

  • $$ - Fügt ein $ ein.
  • $& - Fügt den gefundenen/ersetzten Ausdruck ein.
  • $` - Fügt den Teil ein, der vor der (ersetzte) Ausdruck gefunden wurde.
  • - Fügt den Teil ein, der nach der (ersetzte) Ausdruck gefunden wurde.
  • $n oder $nn - Fügt (ähnlich regulären Ausdrücken) gespeicherte Werte des Vorgangs ein. Anstelle des n ist dabei die Zahl des Speicherplatzes zu setzen.

Beispiel:

a = new String('abcdabcd');
b = a.replace(/(a)(b)/ig,'$2$1($´)'); // = 'ba()cd(abcd)bacd'

Des Weiteren kann ebenso ab JavaScript 1.3 und JScript 5.5 statt einem einzufügenden String auch eine Funktion definiert werden. Diese kann dynamisch einen einzufügenden Wert generieren und diesen an die replace-Methode zurück geben. Eine definierte Funktion bekommt folgende Parameter übergeben (in dieser Reihenfolge):

  • 1. Parameter - Gibt den kompletten String an, der durchsucht wurde.
  • 2. bis n-2 Parameter - Geben die gespeicherten Werte der Suche an ($1 bis $... / siehe reguläre Ausdrücke)
  • Vorletzter Parameter - Gibt die Stelle an, an der Ausdruck auftritt.
  • Letzter Parameter - Gibt den String selbst an.

Beispiel:

function doreplace(a,b,c,d)
{
 // a = 'a'
 // b = $1 = 'a'
 // c = Index
 // d = 'abcdabcdabcd'
 x = ' ('+a+')'+c+' ';
 return(x);
}

a = new String('abcdabcdabcd');
b = a.replace(/(a)/ig,doreplace); 
// = ' (a)0 bcd (a)4 bcd (a)8 bcd'

search

Die search-Methode gibt die Position einer Zeichenfolge oder regulären Ausdrucks in einem String wieder. Als Parameter wird dazu der zu suchende Ausdruck bzw. die Zeichenfolge erwartet. Siehe auch indexOf.
Notation: Objekt.search(Suche)

a = new String('abcde');
b = a.search(/b/ig); // = 1

slice

Die slice-Methode gibt einen Teilstring aus einem String wieder. Als Parameter wird dazu der Anfangsindex der Zeichenkette benötigt. Außerdem kann optional ein Endindex definiert werden. Beide Indexes sind nullbasierend. Wird als Endindex ein negativer Wert angegeben, so wird der Endindex automatisch als Länge plus dem Wert definiert (also z.B. x+(-3)).
Notation: Objekt.slice(Index[,Endindex])

a = new String('abcde');
b = a.slice(2,-1); // = 'cd'

small

Die small-Methode erzeugt einen String, der als klein gekennzeichnet ist und gibt diesen wieder.
Notation: Objekt.small()

a = new String('abcdef');
b = a.small(); // = '<small>abcdef</small>'

split

Die split-Methode zerteilt einen String und gibt die einzelnen Teile innerhalb eines Arrays aus. Als Parameter kann eine Zeichenfolge oder ein regulärer Ausdruck angegeben werden. Diese/r besagt, an welcher Stelle der String zu unterteilen ist. Außerdem kann ein zweiter Parameter angegeben werden. Dieser gibt die maximale Anzahl der Teile, die gefunden werden sollen/dürfen. Wird kein Parameter angegeben oder der Zerteiler nicht gefunden, so wird ein Array mit einem Eintrag zurückgegeben, der den gesamten String enthält.
Notation: Objekt.split(Zeichenfolge[,Anzahl])

a = new String('a b c d e f');
b = a.split(' ',4); // = 'a','b','c','d'

strike

Die strike-Methode erzeugt einen String, der als durchgestrichen gekennzeichnet ist und gibt diesen wieder.
Notation: Objekt.strike()

a = new String('abcdef');
b =&nbnbsp;a.strike(); // = '<strike>abcdef</strike>'

sub

Die sub-Methode erzeugt einen String, der als tiefgestellt gekennzeichnet ist, und gibt diesen wieder.
Notation: Objekt.sub()

a = new String('abcdef');
b = a.sub(); // = '<sub>abcdef</sub>'

substr

Die substr-Methode gibt von einem String einen Teilstring wieder. Dazu wird als Parameter der (nullbasierte) Index des ersten zu extrahierenden Zeichens erwartet. Optional kann als zweiter Parameter eine weitere Zahl übergeben werden. Diese gibt die Länge des zu extrahierenden Strings an. Wird sie nicht definiert, so wird automatisch bis zum Ende des Strings vorgegangen.
Notation: Objekt.substr(Anfang[,Länge])

a = new String('abcdef');
b = a.substr(2,2); // = 'cd'

substring

Die substring-Methode ist ähnlich der substr-Methode. Einzige Unterschiede hierbei sind, dass der zweite Parameter angegeben werden muss. Er besagt hierbei den (nullbasierten) Index des letzten in den Teilstring aufzunehmenden Zeichens. Die Länge des resultierenden Strings ist dabei immer die absolute Zahl der Subtraktion von Start- und Endindex.
Notation: Objekt.substring(Anfang,Ende)

a = new String('abcdef');
b = a.substring(2,4); // = 'cd'

sup

Die sup-Methode erzeugt einen String, der als hochgestellt gekennzeichnet ist und gibt diesen wieder.
Notation: Objekt.sup()

a = new String('abcdef');
b = a.sup(); // = '<sup>abcdef</sup>'

toLowerCase

Die toLowerCase-Methode wandelt sämtliche Großbuchstaben innerhalb eines Strings in Kleinbuchstaben um und gibt den umgewandelten String aus.
Notation: Objekt.toLowerCase()

a = new String('abcdefABCDEF');
b = a.toLowerCase(); // = 'abcdefabcdef'

toSource

Die toSource-Methode gibt einen String wieder, der den Source-Code (Grundcode) des Objekts repräsentiert.
Notation: Objekt.toSource()

a = new String('abcdef');
b = a.toSource();

toString

Die toString-Methode wandelt das Objekt in einen String um. Dies hat bei Strings selbst keinen Effekt.
Notation: Objekt.toString()

a = new String('abcdef');
b = a.toString(); // = 'abcdef'

toUpperCase

Die toUpperCase-Methode wandelt sämtliche Kleinbuchstaben innerhalb eines Strings in Großbuchstaben um und gibt den umgewandelten String aus.
Notation: Objekt.toUpperCase()

a = new String('abcdefABCDEF');
b = a.toUpperCase(); // = 'ABCDEFABCDEF'

valueOf

Die valueOf-Methode gibt den Wert des Strings wieder. Dies entspricht allgemein der toString-Methode.
Notation: Objekt.valueOf()

a = new String('abcdef');
b = a.valueOf(); // = 'abcdef'

Auch interessant