Bitte warten...

JavaScript: Zeichenketten

Zeichenketten (Strings) werden bei der Wertzuweisung in einfachen oder doppelten Anführungsstrichen notiert. Sollen die gleichen Anführungszeichen auch im String enthalten sein, müssen sie mit dem Backslash maskiert werden. Dies gilt ebenso für den Backslash selbst.

Code auswählen
1
2
3
4
5
6
7
      a = "Hallo, Welt!";
      b = 'Guten Morgen!';
      c = "<a href='decocode.de'>Klick</a>";
      d = "<a href=\"decocode.de\">Klick</a>";
      e = '<a href="decocode.de">Klick</a>';
      f = '<a href=\'decocode.de\'>Klick</a>';
      g = "Ein Backslash: \\";

Unicode-Zeichen können mit \x zweistellig hexadezimal und mit \u vierstellig hexadezimal kodiert werden.

Code auswählen
1
2
      str = "Sch\xf6ne Gr\xFC\u00DFe!";
      console.log(str, str.length);  // Schöne Grüße! 13

► JavaScript-Referenz: toString() length charAt()

Mit dem Operator + können Zeichenketten verknüpft werden. Mit dem Operator += kann die Zeichenkette, die als Wert einer Variablen zugewiesen ist, um eine weitere Zeichenkette ergänzt werden.

Ob der Operator + Zeichenketten miteinander verknüpft oder eine Berechnung durchführt, hängt davon ab, welcher Datentyp als erstes gefunden wird, wenn gemischte Datentypen in dem Ausdruck enthalten sind. Beginnt der Ausdruck mit einem String, werden Zahlen als Zeichen interpretiert. Soll dennoch eine Berechnung durchgeführt werden, müssen die Zahlen in Klammern notiert werden. Beginnt der Ausdruck mit Zahlen, werden diese auch wie Zahlen behandelt. Sollen sie wie Zeichen behandelt werden, müssen sie explizit mit der Methode toString() in Zeichen umgewandelt werden.

Die Anzahl der Zeichen in einer Zeichenkette kann mit der Eigenschaft length bestimmt werden. Escape-Zeichen werden dabei ignoriert.

Mit der Methode charAt(x) kann das Zeichen bestimmt werden, dass sich in der Zeichenkette an Position x befindet, wobei die erste Position den Index 0 besitzt. Man kann einen String aber auch als Array von Zeichen betrachten und das gesuchte Zeichen auf diese Weise finden (s. Beispiel).

Code auswählen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
      a = "Hallo ";
      b = "Welt";
      c = a + b;
      a += b;
      d = "Hallo " + "Welt";
      console.log(a);  // Hallo Welt
      console.log("Antwort: " + 4 + 2);  // Antwort: 42
      console.log("Antwort: " + (4 + 2));  // Antwort: 6
      console.log(4 + 2 + " ist die Antwort");  // 6 ist die Antwort
      console.log((4).toString() + (2).toString() + " ist die Antwort");  // 42 ist die Antwort
      console.log(4 + "" + 2 + " ist die Antwort");  // 42 ist die Antwort

      console.log("Hallo Welt".length);  // 10
      console.log("\"Hallo Welt\"".length);  // 12
      
      a = "Καλημέρα!";
      console.log(a.charAt(2));  // λ
      console.log(a[2]);  // λ (String als Array)

► JavaScript-Referenz: substr() substring() slice() indexOf() lastIndexOf()

Mit der Methode substr(x, y) kann die Teilmenge der Zeichenkette ab Position x mit der Länge y bestimmt werden. Wird keine Länge angegeben, wird der restliche String ab Position x zurückgegeben. Wird für x ein negativer Wert angegeben, wird ab der Position des letzten Zeichens zurückgezählt.

Mit der Methode substring(x, y) kann die Teilmenge der Zeichenkette ab Position x bis zu Position y bestimmt werden. Wird keine Position y angegeben, wird der restliche String ab Position x zurückgegeben.

Die Methode slice() funktioniert ähnlich wie substring(), interpretiert aber negative Indizes vom Ende der Zeichenkette an gezählt.

Mit der Methode indexOf(str) kann die erste Position des Strings str in der Zeichenkette gefunden werden. Mit der Methode lastIndexOf(str) kann die letzte Position des Strings str in der Zeichenkette gefunden werden. Wird der String str nicht gefunden, geben sowohl indexOf() als auch lastIndexOf() den Wert -1 zurück.

Code auswählen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
      a = "Hallo, Welt!";
      console.log(a.substr(7));  // Welt!
      console.log(a.substr(7, 4));  // Welt
      console.log(a.substr(-5));  // Welt!
      console.log(a.substr(-5, 4));  // Welt
      
      console.log(a.substring(0));  // Hallo, Welt!
      console.log(a.substring(0, 5));  // Hallo
      
      console.log(a.slice(0));  // Hallo, Welt!
      console.log(a.slice(0, 5));  // Hallo
      console.log(a.slice(7, -1));  // Welt
      
      console.log(a.indexOf("l"));  // 2
      console.log(a.lastIndexOf("l"));  // 9
      console.log(a.indexOf("y"));  // -1
      console.log(a.lastIndexOf("y"));  // -1

► JavaScript-Referenz: startsWith() endsWith() includes()

Mit der Methode startsWith(foo) kann geprüft werden, ob eine Zeichenkette mit dem String foo beginnt.

Mit der Methode endsWith(foo) kann geprüft werden, ob eine Zeichenkette mit dem String foo endet.

Mit der Methode includes(foo) kann geprüft werden, ob eine Zeichenkette den String foo beinhaltet.

Groß- und Kleinschreibung wird bei all diesen Methoden unterschieden.

Code auswählen
1
2
3
4
5
6
7
8
9
10
11
12
      a = "Die Katze tritt die Treppe krumm.";

      console.log(a.startsWith("Die Katze"));  // true
      console.log(a.startsWith("Der Hund"));  // false

      console.log(a.endsWith("krumm."));  // true
      console.log(a.endsWith("niemals."));  // false
      
      console.log(a.includes("Katze"));  // true
      console.log(a.includes("KATZE"));  // false
      console.log(a.includes("hund"));  // false

► JavaScript-Referenz: charCodeAt() fromCharCode() codePointAt() fromCodePoint()

Die Methoden charCodeAt(x) und codePointAt(x) geben beide den dezimalen Unicode-Codepoint des Zeichens an der Position x in der Zeichenkette zurück. Während charCodeAt() den Bereich von hexadezimal 0 bis FFFF umfasst, umfasst codePointAt() den Bereich von 0 bis 10FFFF (s. UTF-16).

Die Methoden fromCharCode(x) und fromCodePoint(x) sind die entsprechenden Umkehrfunktionen. Das heißt, sie geben das Unicode-Zeichen des Codepoints x (dezimal) im zugehörigen Zahlenraum aus.

Unicode-Zeichen können in JavaScript in der Form \uFFFF (hexadezimal) kodiert werden.

Code auswählen
1
2
3
4
5
6
      a = "Καλημέρα!";
      console.log(a.charCodeAt(2));  // 955
      console.log(a.codePointAt(2));  // 955
      console.log("\u03BB".codePointAt(0));  // 955
      console.log(String.fromCharCode(955));  // λ
      console.log(String.fromCodePoint(955));  // λ

► JavaScript-Referenz: replace() trim() trimStart() trimEnd() padStart() padEnd() repeat()

Mit der Methode replace(foo, bar) kann ein Teilstring in einer Zeichenkette durch bar ersetzt werden, wobei foo (der zu ersetzende Teilstring) idealerweise durch einen regulären Ausdruck (ohne Anführungszeichen!) beschrieben wird. Wird für foo ein gewöhnlicher String übergeben, so wird nur das erste Vorkommen von foo ersetzt.

MIt den Methoden trim(), trimStart() und trimEnd() werden Leerzeichen und Zeilenumbrüche am Anfang bzw. am Ende einer Zeichenkette entfernt. trim() entfernt diese Zeichen am Anfang und am Ende, trimStart() nur am Anfang und trimEnd() nur am Ende.

Mit den Methoden padStart(foo, bar) und padEnd(foo, bar) kann ein String mit dem Zeichen bar bis auf eine Gesamtlänge von foo Zeichen aufgefüllt werden. padStart() tut dies am Anfang des Strings, padEnd() dagegen am Ende. Zahlen müssen dazu erst explizit mit toString() in Strings umgewandelt werden.

Die Methode repeat(x) erzeugt einen String aus x Wiederholungen einer Zeichenkette.

Code auswählen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
      a = "   Halloballo   ";
      console.log(a.replace("a", "e"));  //    Helloballo   (ersetzt nur die erste Übereinstimmung)
      console.log(a.replace(/a/g, "e"));  //    Hellobello   (ersetzt alle Übereinstimmungen)
      
      console.log("*" + a.trim() + "*");  // *Halloballo*
      console.log("*" + a.trimStart() + "*");  // *Halloballo   *
      console.log("*" + a.trimEnd() + "*");  // *   Halloballo*
      
      console.log("AA".padStart(4, "+"));  // ++AA
      console.log("A".padStart(4, "+"));  // +++A
      console.log("AA".padEnd(4, "+"));  // AA++
      console.log("A".padEnd(4, "+"));  // A+++
      console.log((12).toString().padStart(4, "0"));  // 0012
      
      console.log("Hallo ".repeat(4));  // Hallo Hallo Hallo Hallo 

► JavaScript-Referenz: toUpperCase() toLowerCase() split()

Die Methode toUpperCase() wandelt alle Kleinbuchstaben in Großbuchstaben um.

Die Methode toLowerCase() wandelt alle Großbuchstaben in Kleinbuchstaben um.

Die Methode split(foo) zerlegt einen String an dem Trennzeichen foo in seine Bestandteile und gibt ein Array mit diesen Teilen zurück.

Code auswählen
1
2
3
4
5
6
7
8
      a = "Die Katze tritt die Treppe krumm.";
      b = a.toUpperCase();
      console.log(b);  // DIE KATZE TRITT DIE TREPPE KRUMM.
      c = b.toLowerCase(b);
      console.log(c);  // die katze tritt die treppe krumm.
      
      d = c.split(" ");
      console.log(d);  // (6) ["die", "katze", "tritt", "die", "treppe", "krumm."]

► JavaScript-Referenz: search() match() matchAll()

MIt der Methode search() kann ermittelt werden, an welcher Position ein String ein Bestandteil enthält, das einem regulären Ausdruck entspricht. Wird kein Bestandteil gefunden, wird -1 zurückgegeben.

Mit der Methode match() kann ein String nach einem durch einen regulären Ausdruck bestimmten Muster durchsucht werden. Es gibt ein Array mit den gefundenen Bestandteilen zurück, wenn der Modifikator g verwendet wird. Ansonsten wird ein Objekt zurückgegeben, das die erste gefundene Übereinstimmung, den entsprechenden Index sowie den gesamten String der Eingabe enthält.

Code auswählen
1
2
3
4
5
6
7
8
9
10
11
      sample = "Die Katze tritt die Treppe krumm.";
      find = sample.search(/[n-z]/gi);
      console.log(find);  // 6 (Index 6: "t")

      sample = "Die Katze tritt die Treppe krumm.";
      find = sample.match(/[A-E]/gi);
      console.log(find);  // (8) ["D", "e", "a", "e", "d", "e", "e", "e"]

      sample = "Die Katze tritt die Treppe krumm.";
      find = sample.match(/[A-E]/i);
      console.log(find);  // ["D", index: 0, input: "Die Katze tritt die Treppe krumm.", groups: undefined]

► JavaScript-Referenz: encodeURI() decodeURI() encodeURIComponent() decodeURIComponent()

Die Methode encodeURI() bewirkt die URL-Kodierung des übergebenen Strings, um bestimmte Zeichen für eine Datenübertragung sicher zu maskieren. Um einen String zu kodieren, damit er für POST- und GET-Requests verwendet werden kann, muss man encodeURIComponent() verwenden, bei der die reservierten Zeichen :/?#@$&+,;= zusätzlich kodiert werden.

decodeURI() und decodeURIComponent() sind die entsprechenden Umkehrfunktionen.

Code auswählen
1
2
3
4
5
6
      str = "http://www.decocode.de/?184&block=0370";
      console.log(encodeURIComponent(str));  // http%3A%2F%2Fwww.decocode.de%2F%3F184%26block%3D0370

      str = ":/?#@$&+,;=";
      console.log(encodeURI(str));  // :/?#@$&+,;=
      console.log(encodeURIComponent(str));  // %3A%2F%3F%23%40%24%26%2B%2C%3B%3D