Todos os artigos

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.

Também em English, Español, Français

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#

EstiloExemploOutros nomes
camelCaseorderTotallowerCamelCase
PascalCaseOrderTotalUpperCamelCase, CapWords (no Python)
snake_caseorder_total
kebab-caseorder-totaldash-case, spinal-case
UPPER_CASEORDER_TOTALSCREAMING_SNAKE_CASE, CONSTANT_CASE
flatcaseordertotalusado em pacotes Go e Java
O mesmo nome, cinco estilos. Cada um tem o seu lugar

O nome kebab vem do espetinho: as palavras ficam espetadas no hífen.

Por linguagem#

JavaScript e TypeScript#

naming.ts
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 const dentro de função continua em camelCase: const diz 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#

naming.py
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.css
.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 (UserProfile em user-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#

orders.sql
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, como fix(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. open sozinho 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: customerId e não cId. 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, loadHttpUrl e não loadHTTPURL, porque fica legível e funciona em qualquer convenção.
  • Eventos e handlers pelo que fazem: saveUserData() diz mais que handleClick(). 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:

eslint.config.mjs
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:

bad.ts
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#

  • Front-end
  • convencoes
  • boas-praticas
  • typescript
  • python
  • css

Escrito por

Engenheira de software e designer. Escrevo sobre o que encontro construindo apps, APIs e produtos.

Comentários

Pra comentar, entre com sua conta do GitHub.