ForHosting KIT · Ferramentas para dev

Detectar estilo do texto: camelCase, snake_case e mais

Convenções de nomenclatura tornam identificadores e rótulos previsíveis, mas textos inconsistentes podem aparecer no código-fonte, em configurações, importações e conteúdo gerado.

● BetaGrátis · no seu navegador

Executar grátis Ver a API

Use pelo WebAPIE-mailTelegramApp em breve

Este detector examina exatamente os caracteres que você fornece e informa se eles seguem camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, Train-Case, dot.case, path/case, Title Case, Sentence case ou uma forma simples em maiúsculas ou minúsculas. A correspondência é rigorosa e determinística: a mesma entrada sempre recebe o mesmo resultado, e textos ambíguos ou irregulares são claramente marcados como mistos.

Entenda o que o detector verifica

O detector compara toda a sua entrada com um conjunto definido de padrões de nomenclatura. Ele não conta apenas letras maiúsculas nem procura somente um separador. Em camelCase, o texto deve começar com letras minúsculas e conter pelo menos uma divisão de palavra indicada por maiúscula. PascalCase começa com maiúscula e une as palavras seguintes sem separadores. Os estilos snake, constant, kebab, dot e path exigem pelo menos dois segmentos não vazios, separados de maneira consistente por sublinhados, hifens, pontos ou barras. Textos separados por espaços são avaliados como Title Case, Sentence case, palavras minúsculas ou palavras maiúsculas. Um resultado bem-sucedido inclui o estilo reconhecido e uma justificativa curta. Se pontuação, separadores inconsistentes, maiúsculas inesperadas ou espaços externos impedirem uma correspondência exata, o resultado será misto, evitando um palpite enganoso. Esse comportamento rigoroso é especialmente útil em validações, pois distingue uma convenção realmente seguida de um texto apenas parecido com ela. Dígitos são aceitos em muitos segmentos de identificadores; entradas vazias e valores que não sejam strings são rejeitados como entrada inválida, sem classificação.

Use a detecção exata para validar convenções

Um rótulo de estilo é mais útil quando faz parte de uma verificação de qualidade repetível. Envie um identificador vindo de formulário, pipeline de dados, gerador de código ou auditoria de nomes e compare o estilo retornado com a convenção esperada pelo seu projeto. Por exemplo, uma política de campos de API pode exigir snake_case, enquanto propriedades JavaScript podem exigir camelCase. Um resultado misto indica que a entrada precisa de revisão, mas o detector não a reescreve de propósito. Manter detecção e conversão separadas evita que uma verificação automatizada altere silenciosamente nomes públicos, colunas de banco de dados ou chaves que talvez já sejam referenciadas. A resposta também traz um booleano de reconhecimento, facilitando decisões: convenções aceitas retornam verdadeiro e textos irregulares retornam falso. A correspondência exata considera espaços no início e no fim, identificando problemas invisíveis de copiar e colar antes que os identificadores entrem no sistema. Para processar muitos valores, chame a capacidade uma vez por item e armazene o valor original e o estilo detectado no relatório de validação. Isso gera um resultado auditável e permite que uma pessoa decida se nomes excepcionais são intencionais.

Interprete limites e entradas ambíguas

Os nomes de estilos podem se sobrepor quando a entrada contém uma única palavra. Por isso, o detector usa uma precedência prática e evita declarar divisões de palavras que não existem. Um único token minúsculo é informado como lowercase, não como camelCase, pois camel case geralmente apresenta pelo menos um segmento unido iniciado por maiúscula. Da mesma forma, um token maiúsculo é UPPERCASE, não CONSTANT_CASE. Formas separadas com várias palavras são mais específicas: customer_order_id é snake_case, CUSTOMER_ORDER_ID é CONSTANT_CASE e Customer Order Id é Title Case. Sentence case requer uma maiúscula inicial seguida por palavras minúsculas separadas por espaços, enquanto Title Case exige que cada palavra comece com maiúscula. Strings com muitas siglas, letras Unicode, apóstrofos, vírgulas, separadores duplicados ou combinações como snake-Case retornam como mistas quando não correspondem exatamente a um padrão aceito. Esse resultado conservador é intencional: adivinhar um rótulo conhecido poderia deixar um identificador malformado passar pela validação. O algoritmo é local e analítico, sem rede, modelo de linguagem, aleatoriedade ou comportamento dependente do tempo. A página permite verificações no navegador, e a automação pela API custa US$ 0,002 por item.

Casos de uso

Padronize campos de API

Verifique se nomes de campos recebidos ou gerados seguem a convenção snake_case ou camelCase exigida por um contrato de API.

Audite chaves de configuração

Classifique chaves de arquivos de configuração e sinalize formas mistas antes que nomes inconsistentes se espalhem pelos ambientes.

Valide identificadores gerados

Teste deterministicamente a saída de geradores de código sem alterar identificadores nem esconder divisões malformadas.

Perguntas frequentes

Quais estilos são reconhecidos?

O detector reconhece camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, Train-Case, dot.case, path/case, Title Case, Sentence case, minúsculas, maiúsculas, palavras minúsculas e palavras maiúsculas.

Por que uma palavra minúscula não é camelCase?

Uma única palavra minúscula não possui uma divisão de palavra unida e, portanto, é classificada como lowercase. camelCase exige pelo menos uma divisão em maiúscula após o início minúsculo.

A ferramenta converte o texto para outro estilo?

Não. Ela apenas detecta o estilo atual. Separar detecção e conversão torna a validação mais segura e mantém a entrada original intacta.

O que ocorre com separadores ou maiúsculas inconsistentes?

O resultado é misto, com reconhecimento falso, pois o texto não segue exatamente uma convenção aceita.

Quanto custa a API?

Cada solicitação à API custa US$ 0,002. A versão para navegador nesta página pode ser executada localmente sem chamada à API.

Para desenvolvedores — acesso via API

Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.

Endpoint

POSThttps://api.kit.forhosting.com/str/detect-case

Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.

Chame do seu código

curl -X POST https://api.kit.forhosting.com/str/detect-case \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"customerOrderId"}'

const res = await fetch("https://api.kit.forhosting.com/str/detect-case", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "text": "customerOrderId"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/str/detect-case",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "text": "customerOrderId"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/detect-case", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"text":"customerOrderId"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"customerOrderId"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/detect-case", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemplo de requisição

{
  "text": "customerOrderId"
}

Exemplo de resposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "str.detect_case",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.

Preço

por chamadaUS$ 0,002

Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.

Erros

HTTP	Código	O que significa
`401`	`unauthorized`	Token ausente ou inválido. Confira o header Authorization.
`402`	`insufficient_balance`	Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo.
`404`	`unknown_type`	Esse tipo de tarefa não existe. Confira o campo type no catálogo.
`429`	`rate_limited`	Muitas requisições em pouco tempo. Espere um instante e tente de novo.

Ver a documentação completa do KIT →