Front-end8 min de leitura
camelCase, PascalCase, kebab-case e snake_case: quando usar
Quando usar camelCase, PascalCase, kebab-case, snake_case e UPPER_CASE em TypeScript, Python, Go, C#, CSS, URLs, banco e Git, com regra de lint testada.

Todo projeto tem aquela discussão: o arquivo é UserProfile.tsx ou user-profile.tsx? A coluna é createdAt ou created_at? A constante vai em maiúsculas? Parece detalhe, mas nome inconsistente custa caro: você erra import, procura a coisa errada no editor e perde tempo em code review discutindo gosto.
A boa notícia é que quase sempre não existe gosto pra discutir. Cada linguagem, formato e ferramenta já tem uma convenção oficial ou dominante. Este post junta as principais num lugar só e explica o porquê de cada uma, que é o que ajuda a lembrar.
Um aviso honesto: as regras de cada linguagem vêm dos guias oficiais (linkados no fim), e a configuração de lint do fim foi testada: um arquivo certo passa e um errado acusa os cinco erros.
TL;DR#
- camelCase (
firstName): variáveis, funções e propriedades em JavaScript, TypeScript, Java e JSON. - PascalCase (
UserProfile): classes, tipos, interfaces e componentes, em quase toda linguagem. - snake_case (
first_name): Python, Rust, Ruby e nomes de tabelas e colunas em banco de dados. - kebab-case (
user-profile): CSS, URLs, nomes de arquivo na web, pacotes npm e branches. - UPPER_CASE (
MAX_RETRIES): constantes e variáveis de ambiente. - A regra que vale mais que todas: siga a convenção da linguagem e do projeto, e deixe uma ferramenta de lint cobrar.
Os nomes de cada estilo#
| Estilo | Exemplo | Outros nomes |
|---|---|---|
| camelCase | orderTotal | lowerCamelCase |
| PascalCase | OrderTotal | UpperCamelCase, CapWords (no Python) |
| snake_case | order_total | |
| kebab-case | order-total | dash-case, spinal-case |
| UPPER_CASE | ORDER_TOTAL | SCREAMING_SNAKE_CASE, CONSTANT_CASE |
| flatcase | ordertotal | usado em pacotes Go e Java |
O nome kebab vem do espetinho: as palavras ficam espetadas no hífen.
Por linguagem#
JavaScript e TypeScript#
export const MAX_RETRIES = 3;
export enum OrderStatus { Pending, Paid }
export interface UserProfile { firstName: string; isAdmin: boolean }
export class OrderService {
private readonly baseUrl = '/api';
getOrders(customerId: string) { return `${this.baseUrl}/customers/${customerId}`; }
}
export function OrderCard() { return null; }
export function formatPrice(value: number) {
const isFree = value === 0;
const headers = { 'Content-Type': 'application/json' };
return isFree ? 'Free' : `${value} ${headers['Content-Type']}`;
}- camelCase pra variáveis, funções, parâmetros, métodos e propriedades.
- PascalCase pra classes, interfaces, tipos, enums e componentes React (o React exige que componente comece com maiúscula, pra diferenciar de tag HTML).
- UPPER_CASE pra constantes de módulo que representam um valor fixo, como um limite ou uma configuração. Uma
constdentro de função continua em camelCase:constdiz que a variável não muda, não que ela é uma "constante" no sentido de configuração.
O guia de estilo de TypeScript do Google segue exatamente essa divisão.
Python#
MAX_RETRIES = 3
class OrderService:
def get_orders(self, customer_id: str) -> list[dict]:
is_cached = customer_id in self._cache
...O PEP 8, guia oficial do Python, define: snake_case pra funções, variáveis e métodos, CapWords (PascalCase) pra classes, UPPER_CASE pra constantes, e nomes de módulo curtos, em minúsculas. O _ na frente (_cache) indica uso interno.
Go#
Go tem uma particularidade: a maiúscula muda o comportamento. Um nome que começa com letra maiúscula (GetOrders) é exportado, visível fora do pacote. Com minúscula (getOrders), fica privado ao pacote. Por isso Go usa MixedCaps e não usa snake_case, e nomes de pacote são curtos e em minúsculas, sem separador.
C# e .NET#
A Microsoft documenta: PascalCase pra classes, métodos e propriedades públicas, camelCase pra parâmetros e variáveis locais, _camelCase pra campos privados, e interfaces começando com I (IOrderService).
Java#
Classes em PascalCase, métodos e variáveis em camelCase, constantes em UPPER_CASE e pacotes todos em minúsculas (com.example.orders).
Rust#
As diretrizes oficiais da linguagem pedem snake_case pra funções, variáveis e módulos, UpperCamelCase pra tipos e traits e SCREAMING_SNAKE_CASE pra constantes. O compilador avisa quando um nome foge disso.
Fora do código#
CSS e HTML#
.order-card { display: grid; }
.order-card__title { font-weight: 600; }
.order-card--selected { outline: 2px solid currentColor; }
:root { --color-accent: #ff385c; }- kebab-case é o padrão do próprio CSS (
background-color,font-weight), e as classes seguem o mesmo estilo. - BEM é uma convenção popular por cima disso: bloco (
order-card), elemento (__title) e modificador (--selected). - Variáveis CSS também em kebab-case, com
--na frente. - Elemento customizado em HTML precisa de hífen no nome, por regra da especificação:
<order-card>vale,<ordercard>não. É assim que o navegador diferencia uma tag sua de uma tag nativa.
URLs#
/artigos/smart-e-dumb-components e não /artigos/smart_e_dumb_components. A documentação do Google pra buscadores recomenda hífen pra separar palavras em URL. Use também só minúsculas: URLs diferenciam maiúscula de minúscula, e /Sobre e /sobre viram duas páginas.
Nomes de arquivo#
Aqui o ecossistema se divide, e o que vale é a convenção do framework:
- Angular: kebab-case, com o guia oficial pedindo que o nome do arquivo combine com a classe (
UserProfileemuser-profile.ts). - React: é comum o arquivo do componente seguir o nome do componente (
UserProfile.tsx), e o resto em kebab-case ou camelCase. Não há regra oficial, então escolha uma e documente. - Python: snake_case, porque o nome do arquivo vira o nome do módulo no
import.
Um cuidado que pega muita gente: o macOS e o Windows, por padrão, não diferenciam maiúscula de minúscula no nome de arquivo, e o Linux diferencia. Se você renomear button.tsx pra Button.tsx no Mac, o Git pode não perceber a mudança, o seu import funciona na sua máquina e quebra na CI, que roda em Linux. Pra trocar só a caixa, use git mv button.tsx Button.tsx.
Banco de dados#
CREATE TABLE customer_orders (
id BIGSERIAL PRIMARY KEY,
customer_id BIGINT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);snake_case em minúsculas é o padrão mais seguro. No PostgreSQL, nomes sem aspas são convertidos pra minúsculas: se você criar a coluna createdAt sem aspas, ela vira createdat. Pra manter a maiúscula, você precisa escrever "createdAt" com aspas em toda consulta, pra sempre.
APIs e JSON#
Não há consenso. O guia de JSON do Google usa camelCase nas propriedades, que é o natural pra quem consome em JavaScript. Muitas APIs públicas grandes usam snake_case. O importante é escolher um e manter na API inteira. Se o banco é snake_case e o front é camelCase, faça a conversão num lugar só, na camada que monta a resposta, e não espalhada pelo código.
Variáveis de ambiente#
DATABASE_URL, API_KEY, NODE_ENV. UPPER_CASE com underscore é a convenção de todo sistema Unix, e a especificação POSIX descreve os nomes das variáveis usadas pelos utilitários assim: letras maiúsculas, dígitos e underscore.
Git#
- Branches: kebab-case com um prefixo do tipo de trabalho:
feat/order-filter,fix/login-redirect. - Mensagens de commit: a especificação Conventional Commits usa
tipo(escopo): descrição, comofix(orders): keep selection after reload.
Além da caixa: nomes que se explicam#
A convenção de maiúsculas é a parte fácil. O que mais ajuda quem lê é o nome dizer o que a coisa é:
- Booleanos como pergunta:
isOpen,hasItems,canEdit,shouldRetry.opensozinho pode ser um verbo, um estado ou uma função. - Funções com verbo:
getOrders,formatPrice,saveDraft. Componente e classe com substantivo:OrderCard,PriceFormatter. - Listas no plural:
ordersé uma lista,orderé um item.orderListé redundante. - Sem abreviação obscura:
customerIde nãocId. A exceção são as que todo mundo conhece:id,url,html. - Siglas como palavra: o guia do Google recomenda tratar a sigla como palavra comum,
loadHttpUrle nãoloadHTTPURL, porque fica legível e funciona em qualquer convenção. - Eventos e handlers pelo que fazem:
saveUserData()diz mais quehandleClick(). O guia de estilo do Angular recomenda isso explicitamente.
Deixe a ferramenta cobrar#
Convenção que depende de memória e de code review se perde. Em TypeScript, a regra naming-convention do typescript-eslint cobra tudo isso no editor e na CI:
import tseslint from 'typescript-eslint';
export default tseslint.config({
files: ['**/*.ts', '**/*.tsx'],
languageOptions: { parser: tseslint.parser, parserOptions: { projectService: true } },
plugins: { '@typescript-eslint': tseslint.plugin },
rules: {
'@typescript-eslint/naming-convention': [
'error',
// Default: camelCase for variables, functions, parameters and members.
{ selector: 'default', format: ['camelCase'] },
// React components are functions written in PascalCase.
{ selector: 'function', format: ['camelCase', 'PascalCase'] },
// Module-level constants may be UPPER_CASE.
{ selector: 'variable', modifiers: ['const', 'global'], format: ['camelCase', 'UPPER_CASE', 'PascalCase'] },
// Types, interfaces, classes and enums in PascalCase.
{ selector: 'typeLike', format: ['PascalCase'] },
{ selector: 'enumMember', format: ['PascalCase'] },
// Booleans read like a question: isOpen, hasItems, canEdit.
{ selector: 'variable', types: ['boolean'], format: ['PascalCase'], prefix: ['is', 'has', 'should', 'can'] },
// Object keys that come from outside (HTTP headers, APIs) are left alone.
{ selector: 'objectLiteralProperty', format: null },
],
},
});Testando com um arquivo errado:
export interface user_profile { first_name: string }
export function Format_price(Value: number) {
const free = Value === 0;
return free;
}O ESLint acusou os cinco problemas: a interface user_profile e a propriedade first_name fora do padrão, a função Format_price, o parâmetro Value e o booleano free sem prefixo de pergunta. O arquivo do começo do post passou sem nenhum erro.
Um detalhe de versão: o typescript-eslint 8.73, a versão atual em novembro de 2026, ainda pede TypeScript abaixo da 6.1. Em projeto que já subiu pro TypeScript 7, confira a compatibilidade antes de instalar.
Pra Python, o Ruff tem as regras do PEP 8 sobre nomes (o grupo N). Em Go e Rust, a própria ferramenta da linguagem já reclama.
Checklist#
- Variáveis e funções no estilo da linguagem (camelCase em JS/TS, snake_case em Python).
- Classes, tipos e componentes em PascalCase.
- Constantes de configuração e variáveis de ambiente em UPPER_CASE.
- CSS, URLs, pacotes e branches em kebab-case, só minúsculas.
- Tabelas e colunas em snake_case, sem aspas.
- Arquivos seguindo a convenção do framework, e troca de caixa feita com
git mv. - Booleanos como pergunta, funções com verbo, listas no plural.
- Uma regra de lint cobrando, em vez de code review.
Referências#
- Guia de estilo de TypeScript do Google
- PEP 8: convenções de nomes no Python
- Effective Go: nomes
- Convenções de nomes no C#
- Rust API Guidelines: nomes
- Guia de estilo do Angular
- Estrutura de URL, Google Search Central
- Guia de estilo de JSON do Google
- Identificadores no PostgreSQL
- Conventional Commits
- naming-convention do typescript-eslint
Comentários
Pra comentar, entre com sua conta do GitHub.
Leia também

Front-end10 min de leitura
Signals no Angular 22: signal, computed, effect e além

Front-end12 min de leitura
Smart e dumb components no Angular e no React, em 2026

Front-end10 min de leitura
Storybook: como começar e até onde vale a pena ir