Convertire in HTTP-Header-Case
content-type diventa Content-Type, x-request-id diventa X-Request-Id e ACCEPT-LANGUAGE diventa Accept-Language. Ogni parte tra trattini passa in minuscolo e poi riceve l'iniziale maiuscola, senza aggiungere, togliere o spostare alcun trattino. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Testo
- content-type
- Testo
- Content-Type
- Originale
- content-type
- Segmenti
- 2
In questo modo content-type diventa Content-Type, x-request-id diventa X-Request-Id e ACCEPT-LANGUAGE diventa Accept-Language, senza modificare posizione o numero dei trattini. Nessun dizionario, accesso alla rete, valore casuale o data può cambiare il risultato.
Che cosa significa il formato delle intestazioni
Content-Type, Cache-Control, Accept-Language e X-Request-Id sono esempi comuni. Il comportamento è volutamente più ristretto rispetto al title case. Non considera gli spazi come separatori, non consulta elenchi di abbreviazioni, non conserva una sigla maiuscola come ID e non prova a indovinare dove aggiungere nuovi trattini.
Di conseguenza, x-request-id restituisce sempre X-Request-Id, senza dipendere da un manuale di stile. La risposta contiene text come valore convertito principale, original come copia esatta per il controllo, segments come numero di parti e method come identificatore stabile. Ripetere l’operazione non modifica un input già formattato.
Questa stabilità rende la capacità adatta a generatori di documentazione, snapshot test, pulizia dei dati e interfacce che richiedono una convenzione unica e inequivocabile.
Come vengono gestiti separatori, maiuscole e segmenti insoliti
I trattini sono dati strutturali dell’input e vengono quindi conservati, non normalizzati. Un trattino iniziale o finale, oppure due trattini consecutivi, crea un segmento vuoto che rimane vuoto nell’output. Questa scelta impedisce a un semplice formattatore di riscrivere identificatori o eliminare informazioni in silenzio.
In ogni segmento non vuoto viene prima applicata la conversione Unicode in minuscolo; successivamente viene capitalizzato il primo carattere con forme maiuscola e minuscola diverse. Le cifre e i segni che lo precedono restano nella stessa posizione, quindi 2fa-token diventa 2Fa-Token. Un segmento composto soltanto da numeri o punteggiatura rimane invariato.
Anche gli spazi vengono conservati e non diventano separatori: questa capacità si aspetta testo delimitato da trattini e non trasforma una frase comune in un nome di campo. L’input deve essere una stringa con almeno un carattere. Il limite di centomila caratteri contiene memoria e tempo di elaborazione.
Casi d'uso
Rendere chiare le configurazioni
Formatti le chiavi con trattini per dashboard, esportazioni di assistenza, audit e vecchie console amministrative.
Domande frequenti
Aggiunge trattini alle frasi comuni?
No. Conserva i trattini esistenti e modifica il caso nei segmenti; non sostituisce gli spazi né inventa separatori.
Mantiene in maiuscolo abbreviazioni come ID?
No. Non esiste un elenco di abbreviazioni, quindi ogni parte segue la stessa regola e x-request-id diventa X-Request-Id. Così il risultato è sempre identico e non dipende da un dizionario di stile.
Che cosa succede quando una parte inizia con una cifra?
Cifre e segni restano dove sono e la maiuscola va alla prima lettera che segue. Così 2fa-token diventa 2Fa-Token, mentre una parte fatta solo di cifre passa invariata.
Si può applicare a un testo già in questo formato?
Sì. Un testo già formattato esce identico, quindi applicare la conversione due volte non cambia mai il risultato. Questo la rende affidabile per generare documentazione o ripulire dati.
Che fine fanno i trattini iniziali o doppi?
Vengono mantenuti. Un trattino all'inizio o alla fine, o due di seguito, lasciano una parte vuota che resta vuota, quindi il numero e la posizione dei trattini non cambiano mai.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/str/header-case \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"content-type"}'const res = await fetch("https://api.kit.forhosting.com/str/header-case", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "content-type"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/header-case",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "content-type"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/header-case", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"content-type"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"content-type"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/header-case", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"text": "content-type"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.header_case",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Limiti
max_chars | 100000 |
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Converta qualsiasi testo di intestazione in HTTP-Header-Case con una regola prevedibile: ogni segmento separato da trattini viene portato in minuscolo e poi riceve l’iniziale maiuscola. L’esecuzione interattiva avviene interamente nel browser e l’API usa la stessa logica deterministica. Gli input vuoti o errati vengono rifiutati chiaramente e ogni conversione API riuscita costa $0.002.
Che cosa significa HTTP-Header-Case
HTTP-Header-Case è una convenzione di presentazione in cui ogni parte separata da un trattino inizia con una lettera maiuscola e prosegue in minuscolo. Il convertitore applica la regola meccanicamente all’intero input: divide il testo in corrispondenza dei trattini, converte ogni segmento in minuscolo, rende maiuscolo il primo carattere dotato di due forme di caso e ricompone i segmenti conservando la struttura originale dei trattini.
Come vengono gestiti separatori, maiuscole e segmenti insoliti
Valori mancanti, null, array, oggetti, booleani e stringhe vuote restituiscono invalid_input. Poiché non vengono usati rete, modelli, archiviazione, casualità o orologio, lo stesso input valido restituisce sempre lo stesso JSON nel browser e tramite API.
Lo usi per presentazione e automazione, non per validare HTTP
L’output riguarda soltanto la formattazione. Inoltre, non sostiene che questa capitalizzazione sia obbligatoria durante la trasmissione. La conversione nel browser è gratuita. Entrambi i canali condividono la stessa funzione pura e quindi le regole non divergono. Il convertitore è particolarmente utile nei punti in cui le persone leggono i nomi dei campi: documentazione API, articoli di assistenza, schermate di configurazione, tabelle generate, esempi di codice, registri delle modifiche e report di test. Non verifica che l’input sia un nome di campo HTTP sintatticamente valido, non consulta registri, non interpreta valori, non unisce duplicati e non decide se il prefisso X- sia opportuno. Protocolli e librerie moderni usano spesso nomi minuscoli e la semantica dei campi HTTP non distingue il caso. Utilizzi questa capacità quando desidera espressamente la presentazione leggibile HTTP-Header-Case; per controllare richieste o risposte reali scelga un validatore o un ispettore. Ogni richiesta automatizzata riuscita costa $0.002; gli errori di validazione sono tipizzati.
Casi di integrazione
Uniformare la documentazione API
Trasformi etichette incoerenti in una presentazione HTTP-Header-Case uniforme prima di pubblicare le pagine di riferimento.
Generare fixture deterministiche
Produca nomi attesi stabili per snapshot, importatori e test di compatibilità senza duplicare la logica del caso.
Domande tecniche
Quanto costa questo convertitore HTTP-Header-Case?
La conversione interattiva è gratuita nel browser. Ogni richiesta API riuscita costa $0.002.
Conserva abbreviazioni come ID o HTTP?
No. La regola porta l’intero segmento in minuscolo prima di capitalizzarne il primo carattere, quindi id diventa Id.
Il risultato convalida un nome di campo HTTP?
No. È una trasformazione visiva, non una convalida sintattica del protocollo né una ricerca in un registro.
I nomi dei campi HTTP distinguono maiuscole e minuscole?
La loro semantica non distingue il caso. Usi questo formato per la presentazione familiare, non perché il protocollo lo richieda.