Convertisseur de Casse

Qu'est-ce que la conversion de casse ?

La conversion de casse est le processus de modification de la capitalisation ou du schéma de séparation des mots d'une chaîne de caractères. Un convertisseur de casse prend une entrée comme "hello world" et la transforme en UPPERCASE, lowercase, Title Case, camelCase, snake_case, kebab-case ou d'autres conventions. La transformation est simple pour un texte ASCII basique, mais des cas particuliers apparaissent avec les acronymes ("XMLParser"), les règles spécifiques à certaines langues (le i turc avec point) et les chaînes à scripts mixtes.

Les langages de programmation, les systèmes de fichiers et les guides de style imposent chacun leurs propres conventions de nommage. Les variables JavaScript utilisent généralement camelCase. Les fonctions et variables Python suivent snake_case selon la PEP 8. Les noms de classes CSS utilisent kebab-case. Les colonnes de base de données varient selon les équipes, mais snake_case domine dans PostgreSQL et MySQL. Passer manuellement d'une convention à l'autre est lent et source d'erreurs, surtout lors de renommages dans des dizaines de fichiers.

Les conventions de casse ont également leur importance en dehors du code. Le Title Case suit des règles définies par des guides de style comme le Chicago Manual of Style et l'APA, où les articles et les courtes prépositions restent en minuscules sauf en début de phrase. La Sentence case ne met en majuscule que le premier mot et les noms propres. L'édition américaine privilégie le Title Case pour les titres ; la plupart de la documentation européenne et technique utilise à la place la Sentence case.

Pourquoi utiliser ce convertisseur de casse ?

Collez n'importe quel texte et convertissez-le instantanément entre neuf formats de casse, sans installer d'extension VS Code ni écrire un script à usage unique.

Cas d'usage du convertisseur de casse

Référence des conventions de casse

Chaque convention de nommage a des règles spécifiques de capitalisation et de séparation des mots. Le tableau ci-dessous présente les neuf formats supportés par cet outil, avec la phrase "the quick brown fox" comme référence.

camelCase vs snake_case vs kebab-case

Ces trois conventions dominent dans le développement logiciel, mais chacune appartient à un écosystème différent. Choisir la mauvaise peut casser les linters, violer les contrats d'API ou produire des bases de code incohérentes.

Exemples de code

Comment convertir entre conventions de casse de façon programmée. Chaque exemple couvre les transformations les plus courantes : camelCase vers snake_case, snake_case vers camelCase, et les conversions basiques majuscules/minuscules/title.

// camelCase → snake_case
function toSnakeCase(str) {
  return str
    .replace(/([a-z])([A-Z])/g, '$1_$2')
    .replace(/[\s-]+/g, '_')
    .toLowerCase()
}
toSnakeCase('myVariableName')  // → "my_variable_name"
toSnakeCase('kebab-case-str')  // → "kebab_case_str"

// snake_case → camelCase
function toCamelCase(str) {
  return str
    .toLowerCase()
    .replace(/[_-](\w)/g, (_, c) => c.toUpperCase())
}
toCamelCase('my_variable_name')  // → "myVariableName"

// Title Case
function toTitleCase(str) {
  return str.replace(/\w\S*/g, w =>
    w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()
  )
}
toTitleCase('the quick brown fox')  // → "The Quick Brown Fox"

import re

text = "the quick brown fox"

# UPPERCASE / lowercase
text.upper()  # → "THE QUICK BROWN FOX"
text.lower()  # → "the quick brown fox"

# Title Case
text.title()  # → "The Quick Brown Fox"

# camelCase
def to_camel(s):
    words = re.split(r'[\s_-]+', s)
    return words[0].lower() + ''.join(w.capitalize() for w in words[1:])

to_camel("my_variable_name")  # → "myVariableName"

# snake_case from camelCase
def to_snake(s):
    return re.sub(r'([a-z])([A-Z])', r'\1_\2', s).lower()

to_snake("myVariableName")  # → "my_variable_name"

# kebab-case
def to_kebab(s):
    return re.sub(r'([a-z])([A-Z])', r'\1-\2', s).replace('_', '-').lower()

to_kebab("myVariableName")  # → "my-variable-name"

package main

import (
	"fmt"
	"regexp"
	"strings"
)

// camelCase → snake_case
func toSnake(s string) string {
	re := regexp.MustCompile("([a-z])([A-Z])")
	snake := re.ReplaceAllString(s, "${1}_${2}")
	return strings.ToLower(snake)
}

// snake_case → camelCase
func toCamel(s string) string {
	parts := strings.Split(strings.ToLower(s), "_")
	for i := 1; i < len(parts); i++ {
		parts[i] = strings.Title(parts[i])
	}
	return strings.Join(parts, "")
}

func main() {
	fmt.Println(toSnake("myVariableName"))  // → my_variable_name
	fmt.Println(toCamel("my_variable_name")) // → myVariableName
	fmt.Println(strings.ToUpper("hello"))    // → HELLO
	fmt.Println(strings.ToUpper("hello world")) // → HELLO WORLD
}

# UPPERCASE
echo "hello world" | tr '[:lower:]' '[:upper:]'
# → HELLO WORLD

# lowercase
echo "HELLO WORLD" | tr '[:upper:]' '[:lower:]'
# → hello world

# camelCase → snake_case (using sed)
echo "myVariableName" | sed 's/\([a-z]\)\([A-Z]\)/\1_\2/g' | tr '[:upper:]' '[:lower:]'
# → my_variable_name

# snake_case → kebab-case
echo "my_variable_name" | tr '_' '-'
# → my-variable-name

Questions fréquentes