String in Titel-Case umwandeln
String in Titel-Case umwandeln
Dieses kostenlose Online-Tool ermöglicht es Ihnen, einen beliebigen Text in Titel-Case-Format umzuwandeln. Es ist keine Installation von Software oder Systemen erforderlich, so dass es einfach und bequem zu verwenden ist. Mit Funktionen wie der Möglichkeit, den Eingabetext zu löschen, den Ausgabetext zu kopieren und Beispieldaten zu verwenden, bietet dieses Tool eine benutzerfreundliche Oberfläche zur Konvertierung von Texten in Titel-Case.
Zweck und Einsatzszenarien
Das Tool dient dazu, Texte in Titel-Case-Format umzuwandeln. Dieses Format wird häufig für Titel von Büchern, Liedern oder Filmen verwendet. Durch die Verwendung dieses Tools können Sie jeden Text in Titel-Case umwandeln, ohne Programmierkenntnisse oder Installationen von Software.
Dieses Tool ist in verschiedenen Szenarien nützlich, darunter:
- Content-Erstellung: Wenn Sie Artikel, Blog-Posts oder andere Arten von Inhalten schreiben, können Sie dieses Tool verwenden, um Überschriften oder Titel in Titel-Case-Format umzuwandeln und Ihrem Inhalt ein professionelles und poliertes Aussehen zu verleihen.
- Datenverarbeitung: Wenn Sie ein Datensatz oder eine Liste von Zeichenfolgen haben, die in Titel-Case umgewandelt werden müssen, kann dieses Tool die Aufgabe effizient ohne Systemabhängigkeiten bewältigen.
- Lernen: Wenn Sie neu in der Programmierung sind und verstehen möchten, wie die Konvertierung von Titel-Case funktioniert, bietet dieses Tool Codebeispiele in verschiedenen Programmiersprachen.
Wie man das Tool verwendet
Die Verwendung des Tools ist unkompliziert. Befolgen Sie die folgenden Schritte, um Ihre Zeichenfolgen in Titel-Schreibweise zu konvertieren:
- Geben Sie die Zeichenfolge ein: Geben Sie in das bereitgestellte Textfeld die Zeichenfolge ein oder fügen Sie sie ein, die Sie in Titel-Schreibweise konvertieren möchten. Wenn Sie beispielsweise die Zeichenfolge "string to title case" eingeben, konvertiert das Tool sie in "String to Title Case".
- Klicken Sie auf die Schaltfläche Konvertieren: Sobald Sie die gewünschte Zeichenfolge eingegeben haben, klicken Sie auf die Schaltfläche Konvertieren. Das Tool konvertiert die Zeichenfolge sofort in das Titel-Schreibweise-Format.
- Kopieren Sie die Ausgabe: Nach der Konvertierung können Sie einfach auf die Schaltfläche "Kopieren" klicken, um die konvertierte Zeichenfolge in die Zwischenablage zu kopieren. Dies ermöglicht es Ihnen, die konvertierte Zeichenfolge einfach an der gewünschten Stelle einzufügen.
Code-Beispiele in verschiedenen Programmiersprachen
Wenn Sie daran interessiert sind, wie die Titel-Schreibweise-Konvertierung in verschiedenen Programmiersprachen implementiert wird, enthält dieser Abschnitt Code-Beispiele und Erklärungen für jede Sprache.
Python
def convert_to_title_case(string):
title_case_words = []
non_title_case_words = ['a', 'an', 'the', 'and', 'but', 'or', 'for', 'nor', 'on', 'at', 'to', 'from', 'by', 'over']
for word in string.split():
if word.lower() in non_title_case_words:
title_case_words.append(word.lower())
else:
title_case_words.append(word.capitalize())
return ' '.join(title_case_words)
## Beispielverwendung
input_string = 'string to title case'
output_string = convert_to_title_case(input_string)
print(output_string)
In Python können wir die Eingabezeichenfolge mit der split()
-Funktion in einzelne Wörter aufteilen. Dann prüfen wir, ob jedes Wort in der Liste der nicht in Titel-Schreibweise geschriebenen Wörter (Artikel, Konjunktionen und Präpositionen) enthalten ist. Wenn ja, konvertieren wir das Wort in Kleinbuchstaben. Andernfalls setzen wir das Wort in Großbuchstaben um. Schließlich fügen wir die Wörter mit der join()
-Methode wieder zusammen.
Java
public class TitleCaseConverter {
public static String convertToTitleCase(String string) {
StringBuilder titleCaseString = new StringBuilder();
String[] words = string.split(" ");
String[] nonTitleCaseWords = {"a", "an", "the", "and", "but", "or", "for", "nor", "on", "at", "to", "from", "by", "over"};
for (String word : words) {
if (containsIgnoreCase(nonTitleCaseWords, word)) {
titleCaseString.append(word.toLowerCase());
} else {
titleCaseString.append(Character.toUpperCase(word.charAt(0))).append(word.substring(1).toLowerCase());
}
titleCaseString.append(" ");
}
return titleCaseString.toString().trim();
}
private static boolean containsIgnoreCase(String[] arr, String word) {
for (String element : arr) {
if (element.equalsIgnoreCase(word)) {
return true;
}
}
return false;
}
// Beispielhafte Verwendung
public static void main(String[] args) {
String inputString = "string to title case";
String outputString = convertToTitleCase(inputString);
System.out.println(outputString);
}
}
In Java teilen wir den Eingabestring mit der split()
Methode in einzelne Wörter auf. Anschließend überprüfen wir, ob jedes Wort im Array der Wörter, die nicht großgeschrieben werden sollen, enthalten ist. Falls ja, wandeln wir das Wort in Kleinbuchstaben um. Andernfalls setzen wir das erste Zeichen groß und wandeln den Rest des Wortes in Kleinbuchstaben um. Zuletzt fügen wir die Wörter zusammen und entfernen führende oder abschließende Leerzeichen.
JavaScript
function convertToTitleCase(string) {
var titleCaseString = "";
var words = string.toLowerCase().split(" ");
var nonTitleCaseWords = [
"a",
"an",
"the",
"and",
"but",
"or",
"for",
"nor",
"on",
"at",
"to",
"from",
"by",
"over",
];
for (var i = 0; i < words.length; i++) {
var word = words[i];
if (nonTitleCaseWords.includes(word)) {
titleCaseString += word;
} else {
titleCaseString += word.charAt(0).toUpperCase() + word.slice(1);
}
titleCaseString += " ";
}
return titleCaseString.trim();
}
// Beispielhafte Verwendung
var inputString = "string to title case";
var outputString = convertToTitleCase(inputString);
console.log(outputString);
In JavaScript teilen wir den Eingabestring mit der split()
Methode in einzelne Wörter auf. Anschließend überprüfen wir, ob jedes Wort im Array der Wörter, die nicht großgeschrieben werden sollen, enthalten ist. Falls ja, behalten wir das Wort bei. Andernfalls setzen wir das erste Zeichen groß und fügen den Rest des Wortes hinzu. Zuletzt fügen wir die Wörter zusammen und entfernen führende oder abschließende Leerzeichen.
Golang
package main
import (
"fmt"
"strings"
)
func convertToTitleCase(s string) string {
titleCaseString := ""
words := strings.Fields(strings.ToLower(s))
nonTitleCaseWords := []string{"a", "an", "the", "and", "but", "or", "for", "nor", "on", "at", "to", "from", "by", "over"}
for _, word := range words {
if contains(nonTitleCaseWords, word) {
titleCaseString += word
} else {
titleCaseString += strings.Title(word)
}
titleCaseString += " "
}
return strings.TrimSpace(titleCaseString)
}
func contains(arr []string, word string) bool {
for _, element := range arr {
if strings.EqualFold(element, word) {
return true
}
}
return false
}
// Beispielverwendung
func main() {
inputString := "string to title case"
outputString := convertToTitleCase(inputString)
fmt.Println(outputString)
}
In Golang teilen wir den Eingabestring mit der Fields()
-Funktion aus dem strings
-Paket in einzelne Wörter auf. Anschließend überprüfen wir, ob jedes Wort in der Liste der nicht-titelcasefähigen Wörter enthalten ist. Wenn es enthalten ist, belassen wir das Wort wie es ist. Andernfalls konvertieren wir das Wort in Titelcase mit Title()
. Schließlich fügen wir die Wörter zusammen und entfernen alle führenden oder abschließenden Leerzeichen.
Ruby
def convert_to_title_case(string)
title_case_string = ''
words = string.downcase.split(' ')
non_title_case_words = ['a', 'an', 'the', 'and', 'but', 'or', 'for', 'nor', 'on', 'at', 'to', 'from', 'by', 'over']
words.each do |word|
if non_title_case_words.include?(word)
title_case_string += word
else
title_case_string += word.capitalize
end
title_case_string += ' '
end
title_case_string.strip
end
## Beispielverwendung
input_string = 'string to title case'
output_string = in_titel_case_konvertieren(input_string)
puts output_string
In Ruby teilen wir den Eingabestring mit split(' ')
in einzelne Wörter auf und konvertieren diese mit downcase()
in Kleinbuchstaben. Anschließend überprüfen wir, ob jedes Wort in der Liste der nicht-titelcasefähigen Wörter enthalten ist. Wenn es enthalten ist, belassen wir das Wort wie es ist. Andernfalls konvertieren wir das Wort in Titelcase mit capitalize()
. Schließlich fügen wir die Wörter zusammen und entfernen alle führenden oder abschließenden Leerzeichen.