Convertitore maiuscole-minuscole online

Cos'è un convertitore di maiuscole-minuscole?

// The tokenizer that powers every programming-case conversion
function tokenize(input) {
  return input
    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')      // lower→upper: parseHTML → parse HTML
    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')   // acronym boundary: XMLHttp → XML Http
    .replace(/([A-Za-z])(\d)/g, '$1 $2')          // letter→digit: file2 → file 2
    .replace(/(\d)([A-Za-z])/g, '$1 $2')          // digit→letter: 2x → 2 x
    .replace(/[\s\-_./\\]+/g, ' ')                // collapse separators
    .split(' ').filter(Boolean);
}

// Then each case is a one-liner over the tokens
const camelCase  = (s) => tokenize(s).map((t, i) => i === 0 ? t.toLowerCase() : cap(t)).join('');
const snakeCase  = (s) => tokenize(s).map(t => t.toLowerCase()).join('_');
const kebabCase  = (s) => tokenize(s).map(t => t.toLowerCase()).join('-');
const PascalCase = (s) => tokenize(s).map(cap).join('');

function cap(t) {
  return t.charAt(0).toUpperCase() + t.slice(1).toLowerCase();
}

Caratteristiche principali

Alternative al convertitore di case a confronto

Esempi di conversione di case

URGENT: PLEASE REVIEW THE Q4 BUDGET PROPOSAL BEFORE FRIDAY

user_profile_image_url

XMLHttpRequest

10 Tips for Faster JavaScript: A Complete Guide

accessControlAllowOrigin

max retries per request

this is fine, everything is going great

Come usare il convertitore di maiuscole-minuscole

1. 1

   Incolla o scrivi il tuo testo

   Clicca nell'editor e digita, oppure incolla un qualunque testo — una frase, un paragrafo, un identificatore, un titolo. Ogni output di case si aggiorna all'istante. Clicca Esempio per caricare una frase rappresentativa se vuoi solo vedere come differiscono i case.

2. 2

   Scorri la griglia

   I sette text case (UPPERCASE, lowercase, Title, Sentence, iNVERSE, aLtErNaTiNg, RaNdOm) sono nella sezione superiore. Gli otto programming case (camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, path/case, Header-Case) sono nella sezione inferiore. Ogni card mostra la sua label di case, una descrizione di una riga e l'output convertito.

3. 3

   Clicca Copia sul case che vuoi

   Ogni card di output ha il proprio piccolo pulsante Copia. Clicca una volta — il case finisce nei tuoi appunti, il pulsante lampeggia "Copiato!" e sei pronto a incollare altrove. Non c'è bisogno di evidenziare prima il testo di output.

4. 4

   Rimescola il random case se serve

   Se vuoi una variante RaNdOm CaSe diversa per lo stesso testo, clicca Rimescola nella barra delle azioni. Cambia solo l'output Random Case; il testo di input e tutti gli altri output restano uguali.

5. 5

   Pulisci quando hai finito

   Clicca Pulisci per svuotare l'editor e resettare ogni output. Esempio ricarica il testo dimostrativo. Tutte le azioni sono istantanee e non vengono mai inviate a un server.

Errori comuni di conversione di case

Input: "the quick brown fox jumps over the lazy dog"
Output snake_case: the_quick_brown_fox_jumps_over_the_lazy_dog
Risultato: un identificatore di 50 caratteri che nessuno vuole.

Input: "quickBrownFox"
Output snake_case: quick_brown_fox
Risultato: un identificatore pulito a tre token.

Input: "a tale of two cities"
Title Case di questo strumento: A Tale Of Two Cities
Atteso (stile AP): A Tale of Two Cities

Usa questo strumento per la capitalizzazione generale.
Usa uno strumento headline in stile AP per i titoli editoriali.
Strumenti diversi, convenzioni diverse.

Input: XMLHttpRequest
Output PascalCase: XmlHttpRequest
Atteso (acronimo preservato): XMLHttpRequest

Accetta l'acronimo title-cased, OPPURE
Preserva manualmente l'acronimo dopo la conversione, OPPURE
Usa un tokenizer che rispetti gli hint sugli acronimi.

Input: https://example.com/api/users
Output snake_case: https_example_com_api_users
Risultato: non è più un URL.

Input: https://example.com/api/users
Lascia stare gli URL — sono già nel formato giusto.
Per l'estrazione di slug, analizza manualmente il path dell'URL.

Obiettivo: "imposta la variabile user.profile.image"
Usare l'output dot.case come nome di variabile: `user.profile.image`
Nella maggior parte dei linguaggi questo è accesso a proprietà, non un identificatore.

Per una singola variabile: userProfileImage (camelCase).
Per una chiave namespaced: user.profile.image (dot.case è corretto).
Allinea il case alla sintassi target.

Input: "e.g. this is an example. Read more."
Output Sentence case: "E.g. This is an example. Read more."
Il `g.` è stato erroneamente trattato come terminatore di frase.

Esegui prima sentence case, poi correggi a mano i pochi casi limite delle abbreviazioni.
Oppure riformula per evitare punti interni alla frase.
(Il rilevamento di frasi di livello NLP è una categoria di strumenti separata.)

Chi usa questo strumento

Sviluppatori che rinominano identificatori tra linguaggi

Migrare una variabile JS a un nome snake_case in Python, o una classe CSS a un componente PascalCase di React, o una variabile d'ambiente a una costante di config. Incolla il nome sorgente una volta, copia l'output giusto — nessuna conversione manuale lettera per lettera.

Backend dev che traducono nomi di header

Gli header HTTP come Content-Type, Access-Control-Allow-Origin, X-Forwarded-For hanno grafie Header-Case specifiche. Incolla un nome di proprietà JS in camelCase, copia la forma canonica dell'header — funziona per le options di fetch(), il middleware server e le configurazioni proxy.

Scrittori che rimuovono il tono ALL-CAPS dalle email

Email e messaggi di chat inoltrati in tutto maiuscolo si leggono come urla. Incollali in Sentence case per disinnescare il tono, o Title Case per mantenere un'aria da titolo curato. Spazi bianchi e punteggiatura sopravvivono intatti.

Marketer che scrivono titoli

Title Case per i titoli, Sentence case per il copy del corpo e le didascalie — la convenzione raccomandata dalla maggior parte delle style guide moderne (AP, Google, Apple). Vedi entrambi in una volta sola per confrontare quale si adatta alla collocazione.

Specialisti SEO che generano slug URL

kebab-case è la convenzione di slug URL che ogni CMS si aspetta. Incolla un titolo di pagina con punteggiatura e maiuscole, copia l'output kebab-case — pronto da inserire in un campo slug di WordPress, Ghost o Hugo. Il tokenizer rimuove pulitamente la punteggiatura.

DBA che danno nome a colonne e tabelle

snake_case per i nomi di colonne e tabelle è la convenzione universale in PostgreSQL, MySQL, SQLite e nella maggior parte degli ORM. Incolla una label leggibile o un nome di campo API in camelCase, copia la versione snake_case.

Frontend dev che scrivono classi CSS

kebab-case per i nomi di classi è la convenzione della specifica CSS (BEM, utility di Tailwind e la maggior parte dei design system). Incolla un nome di componente JS in camelCase, copia la versione kebab-case per il modulo CSS corrispondente.

Creatori di meme ed entusiasti del sarcasmo

aLtErNaTiNg cAsE e RaNdOm CaSe sono i formati spongebob-meme usati per deridere o citare sarcasticamente. Rimescola ritira la variante random senza cambiare l'input — generane qualcuna finché una non ti sembra giusta.

Regole di tokenizzazione e conversione

Regole di tokenizzazione

I token vengono estratti inserendo uno spazio in quattro confini: minuscola-maiuscola (parseHTML → parse HTML), maiuscola-maiuscola-minuscola (XMLHttp → XML Http), lettera-cifra (file2 → file 2) e cifra-lettera (2x → 2 x). Poi i separatori comuni (spazi bianchi, trattino, underscore, punto, slash, backslash) vengono collassati in singoli spazi. I token risultanti vengono divisi, trimmati e i vuoti vengono scartati. Questo corrisponde alle convenzioni di lodash e del pacchetto change-case.

Gli output Programming-case rimuovono la punteggiatura

camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, path/case e Header-Case producono tutti identificatori puliti — la punteggiatura nell'input (virgole, punti, parentesi) viene scartata perché non può comparire nella maggior parte degli identificatori dei linguaggi. Se ti serve preservare la punteggiatura, usa uno degli output text-case (UPPERCASE, lowercase, Title, Sentence, iNVERSE, aLtErNaTiNg, RaNdOm).

Gli output Text-case preservano tutto

UPPERCASE, lowercase, Title Case, Sentence case, iNVERSE cASE, aLtErNaTiNg cAsE e RaNdOm CaSe preservano tutti spazi bianchi, interruzioni di riga e punteggiatura. Incolla un documento multi-paragrafo e la struttura sopravvive — cambia solo il case delle lettere. Queste trasformazioni operano carattere per carattere senza tokenizzazione.

Title Case (variante naive)

Title Case in questo strumento mette in maiuscolo la prima lettera di ogni parola separata da spazi bianchi e mette in minuscolo il resto. Le style guide APA, Chicago e AP raccomandano di mettere in minuscolo articoli e preposizioni brevi (a, an, the, of, in, for); quelle varianti sono abbastanza diverse da meritare uno strumento dedicato. Usa questo Title Case per la capitalizzazione generale; usa uno strumento headline-specifico per i titoli in stile AP.

Rilevamento dei confini di Sentence Case

Sentence case mette tutto in minuscolo, poi mette in maiuscolo la prima lettera dell'input e la prima lettera dopo qualunque terminatore di frase (. ! ? 。 ！ ？) seguito da spazio bianco. Il rilevatore non tenta di disambiguare abbreviazioni come Mr. o U.S.A. — i falsi positivi lì sono più rumorosi del raro case mancato.

Alternating Case usa un toggle globale

aLtErNaTiNg cAsE si alterna tra minuscolo e maiuscolo per ogni lettera, con un toggle globale che si propaga attraverso i confini di parola. I caratteri non-lettera non avanzano il toggle. Questo corrisponde alla convenzione usata da convertcase.net e da altri generatori di meme — prevedibile e riproducibile per lo stesso input.

Random Case usa Math.random()

RaNdOm CaSe esegue un lancio di moneta indipendente per ogni lettera usando Math.random(). Ogni click su Rimescola produce un risultato diverso. La sorgente random non è crittograficamente forte; va bene per il testo informale ma non usarla per la generazione di password (usa il generatore di password dedicato per quello).

Mappature di case Unicode e locale-aware

Usa `toLocaleLowerCase()` e `toLocaleUpperCase()` così i turchi İ/ı con e senza punto, la ß tedesca (che in gestione standard diventa maiuscola SS) e altre mappature di case sensibili al locale vengono gestite correttamente. La tokenizzazione usa \p{L} per riconoscere lettere di qualunque script. Gli output programming-case per default usano caratteri di identificatore ASCII per compatibilità cross-language.

Best practice per scegliere un case

Scegli il case che corrisponde alla tua codebase

Il case giusto per un nome di variabile non è il più carino — è quello che la tua codebase usa già. JavaScript e Java: camelCase per variabili e metodi, PascalCase per le classi. Python, Ruby, Rust: snake_case per tutto tranne i nomi di classe (che sono PascalCase). CSS e URL: kebab-case. Variabili d'ambiente e costanti: CONSTANT_CASE. Allineati alla convenzione locale; la coerenza batte la correttezza teorica.

Usa Sentence case per le microcopy UI

I design system di Google, Apple e Microsoft si sono tutti standardizzati su Sentence case per label di pulsanti, voci di menu, testo di dialog e altre microcopy UI nell'ultimo decennio. Title Case nelle UI ora si legge come antiquato e leggermente urlato. Salva Title Case per i titoli principali, i titoli di pagina e i titoli di libri.

Rimuovi le virgolette smart prima di incollare

Incollare da Microsoft Word, Google Docs o Apple Notes può trascinarsi dietro virgolette smart (""), em-dash (—) e altri caratteri tipografici che sembrano identici a ASCII ma codificano diversamente. Le trasformazioni di case li gestiscono correttamente, ma se stai convertendo in un identificatore programming-case, sostituiscili manualmente con equivalenti ASCII prima per evitare sorprese nel tuo editor di codice.

Converti un identificatore alla volta per i Programming case

camelCase, snake_case, kebab-case, ecc. producono un singolo identificatore dall'intero input. Se incolli una frase in snake_case, ottieni un unico identificatore lungo — tecnicamente corretto ma raramente quello che vuoi. Per la conversione di identificatori, incolla una parola o un composto alla volta. Per testo di lunghezza paragrafo, usa le trasformazioni text-case.

Verifica il round-trip degli acronimi prima del refactor

XMLHttpRequest → xml_http_request → XmlHttpRequest è il round-trip standard; l'acronimo diventa title-cased al ritorno. Se la tua codebase preserva la capitalizzazione originale dell'acronimo (XmlHttpRequest resta come XMLHttpRequest), il round-trip non corrisponderà esattamente. Verifica a campione qualche conversione prima di fare un rename a livello di progetto.

Usa Header-Case per HTTP/1.1, kebab-case per HTTP/2

HTTP/1.1 è case-insensitive per i nomi degli header, ma Header-Case (Content-Type, X-Forwarded-For) è la grafia convenzionale leggibile dall'uomo che tutti usano. HTTP/2 richiede esplicitamente nomi di header in minuscolo — usa kebab-case per quelli (content-type, x-forwarded-for). In caso di dubbio, kebab-case funziona in entrambi i protocolli.

Rimescola il Random Case per varietà, non per sicurezza

Random Case è divertente per i meme ma non è random nel senso crittografico — usa Math.random(), che va bene per varietà visiva ma non per nulla in cui la casualità conti (generazione di password, token di sicurezza, A/B testing). Usa il generatore di password dedicato per la casualità crittografica.

Domande frequenti