String in Titel-Case umwandeln

Texteingabe
Beispiel
Titel-Case-Ausgabe

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:

  1. 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".
  2. 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.
  3. 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.

Häufig gestellte Fragen (FAQ)

Entdecken Sie weitere Tools