Convertitore di maiuscole e minuscole

Cos'è la Conversione di Maiuscole e Minuscole?

La conversione di maiuscole e minuscole è il processo di modifica della capitalizzazione o del pattern di separazione delle parole in una stringa. Un convertitore di maiuscole prende un input come "hello world" e lo trasforma in UPPERCASE, lowercase, Title Case, camelCase, snake_case, kebab-case o altre convenzioni. La trasformazione è immediata per testo ASCII semplice, ma emergono casi particolari con gli acronimi ("XMLParser"), le regole specifiche per lingua (la I puntata turca) e le stringhe in più scritture.

I linguaggi di programmazione, i file system e le guide di stile impongono ciascuno le proprie convenzioni di denominazione. Le variabili JavaScript usano tipicamente camelCase. Le funzioni e le variabili Python seguono snake_case secondo PEP 8. I nomi delle classi CSS usano kebab-case. Le colonne dei database variano in base al team, ma snake_case domina in PostgreSQL e MySQL. Passare manualmente da una convenzione all'altra è lento e soggetto a errori, specialmente quando si rinominano elementi in decine di file.

Le convenzioni di maiuscole contano anche al di fuori del codice. Il Title Case segue regole definite da guide di stile come il Chicago Manual of Style e le norme APA, dove articoli e preposizioni brevi restano in minuscolo a meno che non aprano la frase. Il Sentence case capitalizza solo la prima parola e i nomi propri. L'editoria americana predilige il Title Case per i titoli; la maggior parte dei documenti tecnici europei usa invece il Sentence case.

Perché Usare Questo Convertitore?

Incolla qualsiasi testo e convertilo istantaneamente tra nove formati di maiuscole, senza installare un'estensione VS Code né scrivere uno script usa-e-getta.

Casi d'Uso del Convertitore

Riferimento alle Convenzioni di Maiuscole

Ogni convenzione di denominazione ha regole specifiche per la capitalizzazione e la separazione delle parole. La tabella seguente mostra tutti e nove i formati supportati dallo strumento, con la frase di input "the quick brown fox" come riferimento.

camelCase vs snake_case vs kebab-case

Queste tre convenzioni dominano nello sviluppo software, ma ciascuna appartiene a un ecosistema diverso. Scegliere quella sbagliata rompe i linter, viola i contratti API o produce codebase incoerenti.

Esempi di Codice

Come convertire tra convenzioni di maiuscole in modo programmatico. Ogni esempio copre le trasformazioni più comuni: da camelCase a snake_case, da snake_case a camelCase, e le conversioni di base maiuscolo/minuscolo/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

Domande Frequenti