JavaScript ist eine vielseitige Sprache und bietet eine Fülle von Funktionen für die Arbeit mit Zeichenfolgen. Zeichenfolgen gehören zu den grundlegendsten Datentypen in jeder Programmiersprache. Wenn Sie wissen, wie Sie sie effizient bearbeiten, können Sie Ihre Programmierkenntnisse erheblich verbessern. In diesem Artikel tauchen wir tief in die JavaScript-String-Funktionen ein und bieten detaillierte Erklärungen, Beispiele und Kommentare, die Ihnen helfen, diese zu beherrschen.

Einführung in Strings in JavaScript

In JavaScript ist eine Zeichenfolge eine Zeichenfolge, die zur Darstellung von Text verwendet wird. Zeichenfolgen sind unveränderlich, d. h. sie können nach ihrer Erstellung nicht mehr geändert werden. Stattdessen erstellen String-Operationen neue Strings.

let greeting = "Hello, World!";
console.log(greeting); // Output: Hello, World!

Strings erstellen

Strings können mit einfachen Anführungszeichen, doppelten Anführungszeichen oder Backticks für Vorlagenliterale erstellt werden.

let singleQuoteStr = 'Hello';
let doubleQuoteStr = "Hello";
let templateLiteralStr = `Hello, ${singleQuoteStr}`;
console.log(templateLiteralStr); // Output: Hello, Hello

String-Eigenschaften

• length: Gibt die Länge der Zeichenfolge zurück.

let str = "JavaScript";
console.log(str.length); // Output: 10

String-Methoden

1. charAt()

Gibt das Zeichen an einem angegebenen Index zurück.

let str = "JavaScript";
console.log(str.charAt(0)); // Output: J

2. charCodeAt()

Gibt den Unicode des Zeichens an einem angegebenen Index zurück.

let str = "JavaScript";
console.log(str.charCodeAt(0)); // Output: 74

3. concat()

Verkettet zwei oder mehr Zeichenfolgen und gibt eine neue Zeichenfolge zurück.

let str1 = "Hello, ";
let str2 = "World!";
let result = str1.concat(str2);
console.log(result); // Output: Hello, World!

4. Includes()

Überprüft, ob eine Zeichenfolge einen angegebenen Wert enthält, und gibt „true“ oder „false“ zurück.

let str = "JavaScript is awesome!";
console.log(str.includes("awesome")); // Output: true

5. endetWith()

Überprüft, ob eine Zeichenfolge mit einem angegebenen Wert endet, und gibt „true“ oder „false“ zurück.

let str = "Hello, World!";
console.log(str.endsWith("World!")); // Output: true

6. indexOf()

Gibt den Index des ersten Vorkommens eines angegebenen Werts zurück, oder -1, wenn er nicht gefunden wird.

let str = "JavaScript is awesome!";
console.log(str.indexOf("is")); // Output: 11

7. lastIndexOf()

Gibt den Index des letzten Vorkommens eines angegebenen Werts zurück, oder -1, wenn nicht gefunden.

let str = "JavaScript is awesome! JavaScript is fun!";
console.log(str.lastIndexOf("JavaScript")); // Output: 22

8. match()

Ruft die Übereinstimmungen ab, wenn eine Zeichenfolge mit einem regulären Ausdruck abgeglichen wird.

let str = "JavaScript is awesome!";
let regex = /is/g;
console.log(str.match(regex)); // Output: [ 'is', 'is' ]

9. wiederholen()

Gibt eine neue Zeichenfolge mit einer angegebenen Anzahl von Kopien der Zeichenfolge zurück, für die sie aufgerufen wurde.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

let str = "Hallo!"; console.log(str.repeat(3)); // Ausgabe: Hallo!Hallo!Hallo!

10. ersetzen()

Ersetzt einen angegebenen Wert durch einen anderen Wert in einer Zeichenfolge.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

let str = "JavaScript ist großartig!"; let newStr = str.replace("awesome", "fantastic"); console.log(newStr); // Ausgabe: JavaScript ist fantastisch!

11. search()

Durchsucht eine Zeichenfolge nach einem angegebenen Wert und gibt die Position der Übereinstimmung zurück.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

let str = "JavaScript ist großartig!"; console.log(str.search("awesome")); // Ausgabe: 15

12. Slice()

Extrahiert einen Teil eines Strings und gibt ihn als neuen String zurück.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

let str = "JavaScript"; console.log(str.slice(0, 4)); // Ausgabe: Java

13. split()

Teilt eine Zeichenfolge basierend auf einem angegebenen Trennzeichen in ein Array von Teilzeichenfolgen auf.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

let str = "Hallo Welt!"; let arr = str.split(", "); console.log(arr); // Ausgabe:

14. startetWith()

Überprüft, ob eine Zeichenfolge mit einem angegebenen Wert beginnt, und gibt „true“ oder „false“ zurück.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "Hallo Welt!"; console.log(str.startsWith("Hallo")); // Ausgabe: wahr

15. Teilzeichenfolge()

Extrahiert die Zeichen aus einer Zeichenfolge zwischen zwei angegebenen Indizes.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.substring(0, 4)); // Ausgabe: Java

16. toLowerCase()

Konvertiert eine Zeichenfolge in Kleinbuchstaben.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.toLowerCase()); // Ausgabe: Javascript

17. toUpperCase()

Konvertiert eine Zeichenfolge in Großbuchstaben.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.toUpperCase()); // Ausgabe: JAVASCRIPT

18. trim()

Entfernt Leerzeichen an beiden Enden einer Zeichenfolge.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = " JavaScript "; console.log(str.trim()); // Ausgabe: JavaScript

19. trimStart()

Entfernt Leerzeichen vom Anfang einer Zeichenfolge.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = " JavaScript"; console.log(str.trimStart()); // Ausgabe: JavaScript

20. trimEnd()

Entfernt Leerzeichen vom Ende einer Zeichenfolge.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript "; console.log(str.trimEnd()); // Ausgabe: JavaScript

21. valueOf()

Gibt den Grundwert eines String-Objekts zurück.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = new String("JavaScript"); console.log(str.valueOf()); // Ausgabe: JavaScript

Vorlagenliterale

Vorlagenliterale ermöglichen eingebettete Ausdrücke und erleichtern so die Verkettung von Zeichenfolgen und mehrzeilige Zeichenfolgen.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let name = "John"; let Greeting = `Hallo, ${name}! Wie geht es dir?`; console.log(Begrüßung); // Ausgabe: Hallo, John! Wie geht es dir?

String.raw()

Gibt eine Zeichenfolge zurück, die aus einer Rohvorlagenzeichenfolge erstellt wurde, und ermöglicht den Zugriff auf Rohzeichenfolgen beim Schreiben.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = String.raw`Hello\nWorld!`; console.log(str); // Ausgabe: Hallo\nWelt!

Praxisbeispiele

function reverseString(str) {
    return str.split('').reverse().join('');
}
console.log(reverseString("JavaScript")); // Output: tpircSavaJ

function reverseString(str) { return str.split('').reverse().join(''); } console.log(reverseString("JavaScript")); // Ausgabe: tpircSavaJ

function isPalindrome(str) {
    let cleanedStr = str.replace(/[\W_]/g, '').toLowerCase();
    return cleanedStr === cleanedStr.split('').reverse().join('');
}
console.log(isPalindrome("A man, a plan, a canal, Panama")); // Output: true

function isPalindrome(str) { let cleaningStr = str.replace(/[\W_]/g, '').toLowerCase(); return cleaningStr === cleaningStr.split('').reverse().join(''); } console.log(isPalindrome("Ein Mann, ein Plan, ein Kanal, Panama")); // Ausgabe: wahr

function capitalizeWords(str) {
    return str.split(' ').map(word => word.charAt(0).toUpperCase()   word.slice(1)).join(' ');
}
console.log(capitalizeWords("hello world")); // Output: Hello World

function captializeWords(str) { return str.split(' ').map(word => word.charAt(0).toUpperCase() word.slice(1)).join(' '); } console.log(capitalizeWords("hello world")); // Ausgabe: Hallo Welt

Abschluss

Die Beherrschung von JavaScript-Stringfunktionen ist für eine effiziente Textmanipulation und Datenverarbeitung von entscheidender Bedeutung. Von grundlegenden Operationen wie Verkettung und Slicing bis hin zu fortgeschritteneren Funktionen wie Regex-Matching und Vorlagenliteralen bietet JavaScript einen umfangreichen Satz an Werkzeugen für die Arbeit mit Strings. Wenn Sie diese Funktionen verstehen und nutzen, können Sie saubereren und effizienteren Code schreiben und eine Vielzahl von Programmierherausforderungen bewältigen.

Dieser umfassende Leitfaden behandelt die wichtigsten String-Funktionen in JavaScript, komplett mit Beispielen und Erklärungen. Üben Sie diese Funktionen und experimentieren Sie mit verschiedenen Anwendungsfällen, um Ihr Verständnis zu festigen und Ihre Programmierkenntnisse zu verbessern.