O que é capitalização de texto? História e origens
A palavra inglesa «case» (maiúscula/minúscula) tem uma origem física muito precisa: a tipografia com tipos móveis. Os tipógrafos armazenavam seus tipos em dois compartimentos sobrepostos — o «upper case» (compartimento superior) para letras maiúsculas e o «lower case» (compartimento inferior) para letras minúsculas. Esta metáfora física sobreviveu à era mecânica e à revolução digital, tornando-se vocabulário fundamental da tipografia moderna.
Com o crescimento da programação de computadores, surgiu uma restrição prática: os identificadores não podiam conter espaços. Para nomear variáveis ou funções compostas por várias palavras mantendo a legibilidade, os programadores desenvolveram organicamente diferentes convenções de concatenação. A linguagem C popularizou o sublinhado, Smalltalk inventou o camelCase, Pascal deu nome ao estilo com inicial maiúscula em cada palavra, e o CSS introduziu o hífen como separador nas suas propriedades.
Hoje em dia, um desenvolvedor fullstack navega no mesmo dia entre TypeScript no frontend, Python no backend, SQL no banco de dados e JSON na API REST — cada camada com as suas próprias convenções de nomenclatura. É precisamente por isso que um conversor de capitalização confiável é uma ferramenta do dia a dia.
Todos os tipos de capitalização explicados
camelCase
A primeira palavra é completamente em minúsculas, cada palavra seguinte começa com maiúscula. Sem separador.
Exemplos: myVariableName, getUserById, fetchDataFromApi
Utilizado em: JavaScript (variáveis, funções), TypeScript (variáveis, funções), Java (variáveis, métodos), Swift, Kotlin.
O nome vem das «corcovas» formadas pelas maiúsculas intercaladas, semelhantes ao dorso de um camelo. É o estilo padrão para identificadores não-tipo na maioria das linguagens da família C.
PascalCase (UpperCamelCase)
Como camelCase, mas a primeira palavra também começa com maiúscula. Todas as palavras têm a inicial em maiúscula.
Exemplos: MyClassName, HttpRequestHandler, UserProfileService
Utilizado em: C# (classes, interfaces, métodos), TypeScript (classes, interfaces, enumerações), Java (classes), ecossistema .NET em geral.
PascalCase funciona como um sinal semântico: «isto é um tipo». Foi popularizado pela linguagem Pascal, embora Smalltalk já o usasse de forma semelhante anteriormente.
snake_case
Todas as letras em minúsculas, palavras separadas por sublinhados.
Exemplos: my_variable_name, get_user_by_id, calculate_total_price
Utilizado em: Python (obrigatório pelo PEP 8 para variáveis, funções e módulos), Ruby, Rust, nomes de colunas SQL, biblioteca padrão C.
O sublinhado funciona como um separador visual claro, tornando identificadores longos muito legíveis sem depender de mudanças de capitalização.
kebab-case
Todas as letras em minúsculas, palavras separadas por hífenes.
Exemplos: my-css-class, user-profile-card, background-color
Utilizado em: Propriedades CSS (font-size, border-radius), atributos HTML, slugs de URL, chaves de configuração YAML/TOML.
Na maioria das linguagens de programação, o hífen é interpretado como operador de subtração, portanto kebab-case não pode ser usado como nome de variável. Em CSS e URLs, contudo, é o padrão dominante.
SCREAMING_SNAKE_CASE (UPPER_SNAKE_CASE)
Como snake_case, mas completamente em maiúsculas.
Exemplos: MAX_RETRY_COUNT, API_BASE_URL, DEFAULT_TIMEOUT_MS
Utilizado em: Constantes em praticamente todas as linguagens — Python, JavaScript/TypeScript, Java (static final), macros C, variáveis de ambiente do sistema operativo.
O impacto visual das maiúsculas transmite uma mensagem clara: «este valor não muda em tempo de execução.» Os linters da maioria dos ecossistemas emitem avisos quando esta convenção é violada.
Title Case
A inicial de cada palavra importante fica em maiúscula (artigos, preposições e conjunções ficam em minúsculas segundo alguns guias de estilo).
Exemplos: My Article Title, Introduction to Machine Learning
Utilizado em: Títulos de artigos e livros, rótulos de botões UI, textos de marketing.
Sentence case
Apenas a primeira letra da primeira palavra fica em maiúscula (além de nomes próprios).
Exemplos: This is a paragraph heading
Utilizado em: Prosa normal, alguns rótulos UI, convenções de títulos em línguas europeias.
As diretrizes do Material Design recomendam Sentence case para o corpo do texto e rótulos secundários.
flatcase
Todas as letras em minúsculas, sem qualquer separador.
Exemplos: myvariable, httphandler, packagename
Utilizado em: Nomes de pacotes Go (fmt, http, strconv), nomes de pacotes Java (com.example.myapp).
Flatcase sacrifica a legibilidade em favor da brevidade e só é adequado para nomes curtos de conceito único.
Por que as convenções de nomenclatura são importantes
As convenções de nomenclatura não são uma preferência estética — são um protocolo de comunicação dentro de uma equipa de desenvolvimento.
Quando toda a base de código segue convenções consistentes, os desenvolvedores podem inferir o significado de um identificador apenas pela sua forma:
- Ver
MyServiceem TypeScript indica imediatamente que é um tipo. - Ver
MAX_CONNECTIONSindica que é uma constante. - Ver
user_idnuma consulta SQL indica que é uma coluna de base de dados.
Legibilidade: O estudo de Binkley et al. (2009) mostrou que camelCase é lido mais rapidamente em identificadores curtos no código, enquanto snake_case é mais compreensível em palavras compostas longas.
Consistência de equipa: Misturar getUserById e get_user_by_id no mesmo repositório gera carga cognitiva desnecessária em revisões de código. Linters automatizados como ESLint, flake8 ou golangci-lint podem impor as convenções e eliminar completamente este tipo de debate.
Suporte de ferramentas: A autocompletação do IDE, as ferramentas de refatoração e os geradores de documentação dependem de padrões de nomenclatura consistentes para funcionar corretamente.
Convenções por linguagem
JavaScript / TypeScript
Variáveis e funções: camelCase (let userName, function getData)
Classes e interfaces: PascalCase (class UserService, interface IRepository)
Constantes: SCREAMING_SNAKE (const MAX_SIZE = 100)
Enumerações: PascalCase (enum Direction)
Nomes de ficheiros: kebab-case (user-service.ts, api-client.ts)
Classes CSS: kebab-case (.btn-primary, .card-header)
Python (PEP 8)
Variáveis e funções: snake_case (user_name, get_data)
Classes: PascalCase (class UserService)
Constantes: SCREAMING_SNAKE (MAX_SIZE = 100)
Módulos: snake_case (my_module.py)
Membros privados: _single_leading_underscore
Go
Identificadores exportados: PascalCase (func GetUser, type UserService)
Identificadores não exportados: camelCase (func getUser, var userCount)
Nomes de pacotes: flatcase (package http, package fmt)
Go usa a capitalização como modificador de visibilidade: PascalCase = público (exportado), camelCase = privado (não exportado). O compilador impõe isto.
Java
Variáveis e métodos: camelCase (String userName, void getData())
Classes e interfaces: PascalCase (class UserService)
Constantes: SCREAMING_SNAKE (static final int MAX_SIZE = 100)
Pacotes: flatcase (com.example.myapp)
CSS e HTML
Nomes de classes: kebab-case (.btn-primary, .nav-item)
Propriedades personalizadas: kebab-case (--primary-color, --font-size-lg)
SQL / Bases de dados
Nomes de tabelas: snake_case (user_profiles, order_items)
Nomes de colunas: snake_case (first_name, created_at)
Funcionamento técnico do conversor
Um conversor de capitalização deve resolver dois problemas fundamentais:
- Deteção de limites de palavras: dado um string em qualquer formato, dividi-lo numa lista de tokens (palavras).
- Remontagem: reunir esses tokens no formato alvo.
A deteção de limites usa expressões regulares para identificar pontos de transição:
- De minúscula para maiúscula:
camelCase→camel,Case - Sublinhado ou hífen:
snake_case→snake,case - Espaços em branco
- Limites de dígitos (opcional):
base64Encode→base64,Encode
O caso mais complexo são as siglas: XMLParser deve ser dividido em XML, Parser — não em X, M, L, Parser.
Exemplos de código
Python
import re
def tokenize(text: str) -> list[str]:
"""Divide qualquer convenção de nomenclatura em lista de tokens em minúsculas."""
text = re.sub(r'(?<=[a-z0-9])(?=[A-Z])', '_', text)
text = re.sub(r'(?<=[A-Z])(?=[A-Z][a-z])', '_', text)
words = re.split(r'[\s_\-]+', text)
return [w.lower() for w in words if w]
def to_snake_case(text: str) -> str:
return '_'.join(tokenize(text))
def to_camel_case(text: str) -> str:
words = tokenize(text)
return words[0] + ''.join(w.title() for w in words[1:])
def to_pascal_case(text: str) -> str:
return ''.join(w.title() for w in tokenize(text))
def to_kebab_case(text: str) -> str:
return '-'.join(tokenize(text))
def to_screaming_snake(text: str) -> str:
return '_'.join(tokenize(text)).upper()
# Exemplos
print(to_snake_case("getUserByID")) # get_user_by_id
print(to_camel_case("user_profile")) # userProfile
print(to_pascal_case("my-css-class")) # MyCssClass
print(to_screaming_snake("apiBaseUrl")) # API_BASE_URL
JavaScript / TypeScript
function tokenize(str) {
return str
.replace(/([a-z0-9])([A-Z])/g, '$1_$2')
.replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
.split(/[\s_\-]+/)
.filter(Boolean)
.map(w => w.toLowerCase());
}
function toKebabCase(str) {
return tokenize(str).join('-');
}
function toCamelCase(str) {
const words = tokenize(str);
return words[0] + words.slice(1).map(w => w[0].toUpperCase() + w.slice(1)).join('');
}
function toPascalCase(str) {
return tokenize(str).map(w => w[0].toUpperCase() + w.slice(1)).join('');
}
// Exemplos
console.log(toKebabCase('MyBackgroundColor')); // my-background-color
console.log(toCamelCase('user_profile_page')); // userProfilePage
console.log(toPascalCase('get-user-by-id')); // GetUserById
Go
package main
import (
"strings"
"unicode"
)
func tokenize(s string) []string {
var words []string
var current strings.Builder
runes := []rune(s)
for i, r := range runes {
if r == '_' || r == '-' || r == ' ' {
if current.Len() > 0 {
words = append(words, strings.ToLower(current.String()))
current.Reset()
}
continue
}
if unicode.IsUpper(r) && current.Len() > 0 {
if i+1 < len(runes) && unicode.IsLower(runes[i+1]) {
words = append(words, strings.ToLower(current.String()))
current.Reset()
}
}
current.WriteRune(r)
}
if current.Len() > 0 {
words = append(words, strings.ToLower(current.String()))
}
return words
}
func ToCamelCase(s string) string {
words := tokenize(s)
if len(words) == 0 {
return ""
}
result := words[0]
for _, w := range words[1:] {
result += strings.Title(w)
}
return result
}
Casos de uso reais
Design de APIs e documentação
Ao projetar uma API REST, é fundamental manter consistência entre os slugs de URL (kebab-case), as chaves do payload JSON (camelCase no ecossistema JavaScript, snake_case em Python) e as colunas da base de dados (snake_case).
Cadeia de conversão típica:
- Coluna BD:
user_created_at - Resposta JSON:
userCreatedAt - Parâmetro URL:
user-created-at - Constante no código:
USER_CREATED_AT
Migrações de bases de dados
Ao migrar entre ORMs ou motores de base de dados, as convenções de nomenclatura de colunas frequentemente diferem. ActiveRecord (Ruby on Rails) prefere snake_case; alguns sistemas legados usam PascalCase. Uma conversão em lote poupa horas de trabalho tedioso.
Refatoração de código
Grandes bases de código acumulam nomenclaturas inconsistentes de diferentes épocas ou contribuidores. Durante sprints de refatoração, o conversor ajuda a processar listas de identificadores rapidamente, combinado com a funcionalidade de renomeação em lote do IDE.
Comparação: regex manual vs bibliotecas
JavaScript: change-case
import { camelCase, snakeCase, pascalCase, kebabCase } from 'change-case';
camelCase('user_profile_page'); // 'userProfilePage'
snakeCase('getUserById'); // 'get_user_by_id'
pascalCase('my-css-class'); // 'MyCssClass'
kebabCase('MyBackgroundColor'); // 'my-background-color'
Trata corretamente Unicode, acrónimos e números.
JavaScript: Lodash
import _ from 'lodash';
_.camelCase('Foo Bar'); // 'fooBar'
_.snakeCase('fooBar'); // 'foo_bar'
_.kebabCase('fooBar'); // 'foo-bar'
Python: inflection
import inflection
inflection.camelize('device_type') # 'DeviceType'
inflection.underscore('DeviceType') # 'device_type'
inflection.dasherize('device_type') # 'device-type'
Implementação própria vs biblioteca: Em produção, prefira bibliotecas (melhor tratamento de casos extremos, suporte Unicode, manutenção pela comunidade). Implemente a sua própria solução apenas em ambientes restritos onde não é possível adicionar dependências.
Boas práticas
1. Consistência acima da preferência pessoal
A melhor convenção de nomenclatura para um projeto é a que toda a equipa usa uniformemente. Misturar snake_case e camelCase na mesma base de código é pior do que usar qualquer um deles de forma exclusiva.
2. Automatizar com linters
Não dependa da memória dos desenvolvedores:
- ESLint com
@typescript-eslint/naming-convention(JavaScript/TypeScript) - flake8 com o plugin
pep8-naming(Python) - golangci-lint com o linter
revive(Go) - RuboCop (Ruby)
3. Documentar as convenções
Adicione uma secção no CONTRIBUTING.md do seu projeto especificando qual convenção se aplica a cada tipo de identificador.
4. Respeitar os idiomas da linguagem
Não imponha convenções externas a uma linguagem. Usar camelCase em Python porque «o resto da stack usa» é um antipadrão — combate as ferramentas da linguagem e as expectativas de qualquer desenvolvedor Python.
5. Gerir acrónimos de forma consistente
Escolha uma abordagem e documente-a:
XMLParserouXmlParserouxmlParser?userIDouuserId?- O guia de estilo Go da Google prefere
userIDexmlParser; a maioria dos guias JS prefereuserIdexmlParser.
Perguntas frequentes
P: PascalCase e UpperCamelCase são a mesma coisa? Sim, são exatamente a mesma convenção. «PascalCase» é mais comum na comunidade de desenvolvimento. «UpperCamelCase» é usado em documentos académicos ou formais para o distinguir do camelCase normal (às vezes chamado lowerCamelCase).
P: Por que não posso usar kebab-case para nomes de variáveis em JavaScript?
Porque o hífen - é o operador de subtração em JavaScript (e na maioria das linguagens da família C). A expressão my-variable é analisada como my menos variable, não como um identificador único. Linguagens de configuração (YAML, CSS) não têm esta restrição.
P: O conversor trata caracteres Unicode e não-ASCII?
As implementações robustas sim. Abordagens baseadas em regex simples podem tratar letras acentuadas (é, ü, ñ) como limites de palavras ou perder a sua informação de capitalização. Bibliotecas como change-case para JavaScript tratam corretamente os casos Unicode mais comuns.
P: Que capitalização devo usar para ficheiros de componentes React?
A comunidade React usa PascalCase tanto para o nome do componente como para o nome do ficheiro: UserProfileCard.tsx. Isto distingue os ficheiros de componentes dos ficheiros utilitários (utils.ts, api-client.ts) à primeira vista.
P: Como devo tratar números nos identificadores?
A maioria dos tokenizadores trata uma sequência de dígitos como o seu próprio token. base64Encoder → base64, Encoder → base64_encoder em snake_case. Certifique-se de que o seu tokenizador trata de forma consistente termos comuns como md5, sha256, oauth2.
P: As colunas da base de dados devem usar snake_case mesmo que a aplicação use camelCase?
Quase sempre sim. O SQL não é sensível a maiúsculas/minúsculas na maioria das bases de dados, e firstName pode ser interpretado de forma diferente por diferentes ferramentas. snake_case é a convenção SQL universal e é compreendida por todos os ORMs. O mapeamento para camelCase faz-se na camada da aplicação.
P: Que capitalização devo usar para variáveis de ambiente?
SCREAMING_SNAKE_CASE é o padrão universal para variáveis de ambiente: DATABASE_URL, JWT_SECRET, PORT. Esta convenção é seguida pela metodologia Twelve-Factor App, Docker, Kubernetes e praticamente todas as plataformas de implantação.
P: Posso misturar convenções de capitalização num mesmo identificador?
Não — isso indica sempre um erro. Identificadores como myVariable_Name ou My-ClassName são malformados e devem ser corrigidos. As únicas exceções são convenções intencionalmente estabelecidas, como os __dunder__ do Python.
Visão Geral
A formatação de texto é uma parte fundamental da codificação e da escrita. O nosso Conversor de Capitalização é um utilitário de alto desempenho concebido para ajudar os utilizadores a transformar instantaneamente a capitalização do seu texto. Quer precise de corrigir um erro de "CAPS LOCK" ou converter um nome de variável para uma linguagem de programação diferente, a nossa ferramenta oferece um conjunto abrangente de opções para realizar o trabalho sem ter de reescrever manualmente.
Principais Recursos
- Vários Modos de Capitalização: Suporta MAIÚSCULAS, minúsculas, Frase (Sentence case), Título (Title Case), camelCase, PascalCase, snake_case e kebab-case.
- Transformação em Tempo Real: Veja o seu texto mudar instantaneamente enquanto escreve ou cola.
- Interface Limpa: Concebida para ser rápida, com botões de cópia e limpeza num só clique.
- Compatibilidade Universal: Funciona com qualquer texto UTF-8, suportando caracteres especiais e diversos idiomas.
Como Usar
- Colar o Texto: Introduza o texto que deseja transformar na caixa de entrada.
- Escolher o Modo: Selecione o formato de capitalização desejado no menu.
- Ajustar: Ative opções como "Remover espaços extra", se disponível.
- Copiar: Clique no botão de cópia para obter o seu texto recém-formatado.
Casos de Uso Comuns
- Codificação e Scripting: Converta rapidamente
nomes_de_variaveisparacamelCaseouUPPER_SNAKE_CASEpara diferentes convenções. - Edição de Conteúdo: Corrija frases acidentalmente em maiúsculas ou formate títulos para artigos de blog.
- Gestão de Bases de Dados: Padronize nomes de campos ou valores de entrada durante a limpeza de dados.
- Redes Sociais: Crie texto estilizado para publicações e biografias.
Contexto Técnico
A ferramenta utiliza Expressões Regulares (Regex) especializadas para identificar limites de palavras e aplicar a lógica de transformação. Por exemplo, para converter para camelCase, o algoritmo identifica espaços, sublinhados e hífenes, remove-os e coloca em maiúscula a primeira letra das palavras seguintes.
Perguntas Frequentes
- É seguro? Sim, todas as transformações ocorrem no seu navegador; nunca armazenamos o seu texto.
- Suporta textos grandes? Sim, pode processar milhares de palavras instantaneamente.
- Posso anular? Utilize o padrão CMD/CTRL+Z do navegador ou simplesmente mude o modo novamente.
Limitações
- Nuances Contextuais: O modo Frase (Sentence case) pode nem sempre reconhecer nomes próprios corretamente.
- Acrónimos: A transformação para Título (Title Case) pode colocar alguns acrónimos em minúsculas, dependendo do algoritmo.
- Símbolos Complexos: Caracteres não alfanuméricos são geralmente preservados, mas podem afetar a deteção de limites.