Conversor de Capitalização

O Que É Conversão de Capitalização de Texto?

A conversão de capitalização de texto é o processo de alterar o padrão de letras maiúsculas/minúsculas ou de separação de palavras em uma string. Um conversor de capitalização recebe uma entrada como "hello world" e a transforma em UPPERCASE, lowercase, Title Case, camelCase, snake_case, kebab-case ou outras convenções. A transformação é simples para texto ASCII básico, mas casos especiais surgem com siglas ("XMLParser"), regras específicas de localidade (I pontilhado do turco) e strings com múltiplos alfabetos.

Linguagens de programação, sistemas de arquivos e guias de estilo cada um impõe suas próprias convenções de nomenclatura. Variáveis JavaScript normalmente usam camelCase. Funções e variáveis Python seguem snake_case conforme o PEP 8. Nomes de classes CSS usam kebab-case. Colunas de banco de dados variam por equipe, mas snake_case domina no PostgreSQL e MySQL. Alternar entre essas convenções manualmente é lento e sujeito a erros, especialmente ao renomear variáveis em dezenas de arquivos.

As convenções de capitalização também importam fora do código. Title Case segue regras definidas por guias de estilo como o Chicago Manual of Style e a APA, onde artigos e preposições curtas ficam em minúsculas a menos que iniciem a frase. Sentence case capitaliza apenas a primeira palavra e substantivos próprios. A publicação em inglês americano adota Title Case para títulos; a maioria da documentação europeia e de tecnologia usa Sentence case.

Por Que Usar Este Conversor de Capitalização?

Cole qualquer texto e converta-o entre nove formatos de capitalização instantaneamente, sem instalar uma extensão do VS Code ou escrever um script avulso.

Casos de Uso do Conversor de Capitalização

Referência de Convenções de Capitalização

Cada convenção de nomenclatura tem regras específicas de capitalização e separação de palavras. A tabela abaixo mostra os nove formatos suportados por esta ferramenta, usando a frase "the quick brown fox" como referência.

camelCase vs snake_case vs kebab-case

Essas três convenções dominam no desenvolvimento de software, mas cada uma pertence a um ecossistema diferente. Escolher a errada quebra linters, viola contratos de API ou gera bases de código inconsistentes.

Exemplos de Código

Como converter entre convenções de capitalização de forma programática. Cada exemplo cobre as transformações mais comuns: camelCase para snake_case, snake_case para camelCase, e conversões básicas de maiúsculas/minúsculas e title case.

// 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

Perguntas Frequentes