Convertisseur de chaîne en majuscule initiale

Saisie de texte

Exemple

Sortie en majuscules initiales

Convertisseur de chaînes en majuscule initiale

Cet outil en ligne et gratuit vous permet de convertir une chaîne donnée en format majuscule initiale. Il ne dépend d'aucun système ou logiciel, le rendant accessible et pratique à utiliser. Avec des fonctionnalités telles que la suppression de l'entrée, la copie de la sortie et l'exemple de texte, cet outil offre une interface conviviale pour convertir des chaînes en majuscule initiale.

Objectif et scénario

L'objectif de l'outil est de convertir des chaînes en majuscule initiale. La majuscule initiale est couramment utilisée pour écrire des titres, tels que le titre d'un livre, d'une chanson ou d'un film. En utilisant cet outil, vous pouvez facilement convertir n'importe quelle chaîne en majuscule initiale sans avoir besoin de connaissances en programmation ou d'installation de logiciels.

Cet outil est bénéfique dans différents scénarios, notamment:

Création de contenu: Lors de l'écriture d'articles, de billets de blog ou de tout autre type de contenu, vous pouvez utiliser cet outil pour convertir les titres en majuscule initiale, donnant ainsi à votre contenu un aspect professionnel et poli.
Traitement de données: Si vous disposez d'un ensemble de données ou d'une liste de chaînes à convertir en majuscule initiale, cet outil peut gérer efficacement la tâche sans aucune dépendance système.
Apprentissage: Si vous êtes nouveau dans la programmation et que vous voulez comprendre comment fonctionne la conversion en majuscule initiale, cet outil fournit des exemples de code dans différents langages de programmation.

Comment utiliser l'outil

L'utilisation de l'outil est simple. Suivez les étapes ci-dessous pour convertir vos chaînes en majuscules :

Entrez la chaîne : Dans la zone de texte fournie, entrez ou collez la chaîne que vous souhaitez convertir en majuscules. Par exemple, si vous entrez la chaîne "string to title case", l'outil la convertira en "String to Title Case".
Cliquez sur le bouton Convertir : Une fois que vous avez entré la chaîne souhaitée, cliquez sur le bouton Convertir. L'outil convertira instantanément la chaîne en majuscules.
Copiez la sortie : Après la conversion, vous pouvez simplement cliquer sur le bouton Copier pour copier la chaîne convertie dans votre presse-papiers. Cela vous permet de coller facilement la chaîne convertie où vous en avez besoin.

Exemples de code dans différents langages de programmation

Si vous êtes intéressé par la compréhension de la conversion en majuscules dans différents langages de programmation, cette section fournit des exemples de code et des explications pour chaque langage.

Python

def convert_to_title_case(string):
    titres_mots = []
    non_titre_mots = ['un', 'une', 'le', 'la', 'les', 'et', 'mais', 'ou', 'donc', 'or', 'ni', 'sur', 'à', 'de', 'par', 'au-dessus']

    for word in string.split():
        if word.lower() in non_titre_mots:
            titres_mots.append(word.lower())
        else:
            titres_mots.append(word.capitalize())

    return ' '.join(titres_mots)

## Exemple d'utilisation
input_string = 'string to title case'
output_string = convert_to_title_case(input_string)
print(output_string)

En Python, nous pouvons diviser la chaîne d'entrée en mots individuels à l'aide de la fonction split(). Ensuite, nous vérifions si chaque mot se trouve dans la liste des mots non-titre (articles, conjonctions et prépositions). S'il est, nous convertissons le mot en minuscule. Sinon, nous mettons le mot en majuscule initiale. Enfin, nous joignons les mots ensemble à l'aide de la méthode join().

Java

public class TitleCaseConverter {
    public static String convertToTitleCase(String string) {
        StringBuilder titleCaseString = new StringBuilder();
        String[] words = string.split(" ");
        String[] nonTitleCaseWords = {"un", "une", "le", "la", "les", "et", "mais", "ou", "donc", "or", "ni", "sur", "à", "de", "par", "au-dessus"};

        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;
    }

    // Exemple d'utilisation
    public static void main(String[] args) {
        String inputString = "string to title case";
        String outputString = convertToTitleCase(inputString);
        System.out.println(outputString);
    }
}

En Java, nous divisons la chaîne d'entrée en mots individuels à l'aide de la méthode split(). Ensuite, nous vérifions si chaque mot se trouve dans le tableau des mots non-titres. Si c'est le cas, nous convertissons le mot en minuscules. Sinon, nous mettons la première lettre en majuscule et convertissons le reste des caractères en minuscules. Enfin, nous joignons les mots ensemble et éliminons les espaces en début et en fin de chaîne.

JavaScript

function convertToTitleCase(string) {
  var titleCaseString = "";
  var words = string.toLowerCase().split(" ");
  var nonTitleCaseWords = [
    "un",
    "une",
    "le",
    "la",
    "les",
    "et",
    "mais",
    "ou",
    "donc",
    "or",
    "ni",
    "sur",
    "à",
    "de",
    "par",
    "au-dessus",
  ];

  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();
}

// Exemple d'utilisation
var inputString = "string to title case";
var outputString = convertToTitleCase(inputString);
console.log(outputString);

En JavaScript, nous divisons la chaîne d'entrée en mots individuels à l'aide de la méthode split(). Ensuite, nous vérifions si chaque mot se trouve dans le tableau des mots non-titres. Si c'est le cas, nous gardons le mot tel quel. Sinon, nous mettons la première lettre en majuscule et ajoutons le reste du mot. Enfin, nous joignons les mots ensemble et éliminons les espaces en début et en fin de chaîne.

Golang

package main

import (
    "fmt"
    "strings"
)

// Cette fonction prend en entrée une chaîne de caractères et renvoie une version en majuscule de chaque mot, sauf pour une liste de mots courants qui ne doivent pas être en majuscules.
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)
}

// Cette fonction vérifie si un élément est présent dans un tableau.
func contains(arr []string, word string) bool {
    for _, element := range arr {
        if strings.EqualFold(element, word) {
            return true
        }
    }
    return false
}

// Exemple d'utilisation
func main() {
    inputString := "string to title case"
    outputString := convertToTitleCase(inputString)
    fmt.Println(outputString)
}

En Golang, nous divisons la chaîne d'entrée en mots individuels à l'aide de la fonction Fields() du package strings. Ensuite, nous vérifions si chaque mot est présent dans la liste des mots qui ne doivent pas être en majuscules. Si c'est le cas, nous gardons le mot tel quel. Sinon, nous convertissons le mot en majuscules à l'aide de Title(). Enfin, nous joignons les mots ensemble et supprimons les espaces en début et fin de la chaîne.

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

## Cette fonction prend en entrée une chaîne de caractères et renvoie une version en majuscule de chaque mot, sauf pour une liste de mots courants qui ne doivent pas être en majuscules.
## Exemple d'utilisation
input_string = 'string to title case'
output_string = convertir_en_majuscules(input_string)
puts output_string

En Ruby, nous divisons la chaîne d'entrée en mots individuels en utilisant la méthode split(). Ensuite, nous vérifions si chaque mot est dans le tableau de mots non en majuscules. Si c'est le cas, nous conservons le mot tel quel. Sinon, nous mettons le mot en majuscule. Enfin, nous joignons les mots ensemble et supprimons les espaces en début et en fin.

Outils connexes

Convertir une chaîne de caractères en snake case Convertir une chaîne de caractères en minuscules Convertir une chaîne de caractères en majuscules Convertir une chaîne en CamelCase Convertisseur de texte en majuscules Convertir une chaîne de caractères en format Upper Snake Case Convertisseur de chaîne en format de cas de point Chaîne en format paramètre String to Pascal Case Convertisseur de chaîne en format de chemin

Foire aux questions (FAQ)

Découvrez nos autres outils

Convertir une chaîne de caractères en snake case Convertir une chaîne de caractères en minuscules Convertir une chaîne de caractères en majuscules Convertir une chaîne en CamelCase Convertisseur de texte en majuscules Convertir une chaîne de caractères en format Upper Snake Case Convertisseur de chaîne en format de cas de point Convertisseur de chaîne en majuscule initiale Chaîne en format paramètre String to Pascal Case Convertisseur de chaîne en format de chemin