ForHosting KIT · Strumenti per sviluppatori

Convertire in COBOL-CASE

Il convertitore COBOL-CASE trasforma testo comune, identificatori misti ed etichette formattate in modo irregolare in uno stile uniforme e marcato: ogni parola rilevata diventa maiuscola e le parole adiacenti vengono unite con un solo trattino.

● BetaGratis · nel tuo browser

Esegui gratis nel browser Vedi l'API

Usalo da WebAPIEmailTelegramApp presto

Inserendo customer account record, Lei ottiene CUSTOMER-ACCOUNT-RECORD. Lo strumento riconosce anche i comuni confini camelCase e PascalCase, sostituisce punteggiatura e separatori esistenti e conserva le cifre come elementi utili. La conversione è deterministica: lo stesso input produce sempre lo stesso risultato nel browser, in uno script di build, in un flusso API o in una pipeline per generare configurazioni.

Trasformi testi diversi in identificatori prevedibili in stile COBOL

COBOL-CASE è una convenzione molto evidente composta da parole maiuscole separate da trattini. È associata al codice COBOL classico, alle definizioni di dati legacy, ai nomi dei comandi, alle chiavi di configurazione e ai documenti in cui gli identificatori devono risaltare. Questo convertitore elimina il lavoro ripetitivo di individuare ogni parola, uniformarne le maiuscole e correggere manualmente i separatori. Lei può fornire una frase, un’etichetta copiata o un identificatore scritto con un altro stile. Il risultato contiene lettere ASCII e cifre organizzate in elementi maiuscoli con esattamente un trattino tra elementi vicini. Spazi, underscore, trattini esistenti e punteggiatura fungono da confini, trasformando una fonte incoerente in una rappresentazione stabile. La risposta include anche il numero di parole, così un processo automatico può verificare l’interpretazione. Nessun dato viene archiviato o recuperato dall’esterno e il risultato non cambia tra le esecuzioni.

Comprenda come vengono gestiti confini e caratteri

Il convertitore verifica innanzitutto che il testo esista, sia una stringa, rispetti il limite pubblicato e contenga almeno una lettera ASCII o una cifra. Poi rileva i confini comuni in camelCase e PascalCase. Per esempio, customerAccount diventa CUSTOMER-ACCOUNT, mentre XMLParser diventa XML-PARSER anziché XMLPARSER. Anche i passaggi fra lettere e numeri creano confini: report2026Final produce REPORT-2026-FINAL. Le sequenze di spazi o segni vengono ridotte a un separatore e non creano mai trattini doppi o finali. Ogni elemento viene convertito in maiuscolo e unito con un trattino. Questa scelta volutamente rigorosa genera output portabile per strumenti datati con regole Unicode divergenti. Lettere accentate e simboli agiscono da separatori invece di essere traslitterati silenziosamente. Un input di soli segni o spazi restituisce un errore. L’algoritmo non consulta impostazioni locali, dizionari o orologi.

Usi il browser una tantum e l’API nei flussi ripetibili

Per una conversione occasionale, Lei può incollare il testo nello strumento del browser e copiare il risultato in un file sorgente, un documento di configurazione, una nota di migrazione o una fixture di test. Per attività ripetute, può chiamare l’API da un generatore, una pipeline di importazione, un comando dell’editor o un controllo di integrazione continua. La richiesta contiene un solo campo di testo obbligatorio e costa $0.002; browser e API eseguono la stessa logica pura. Un flusso utile normalizza i nomi prima di confrontarli, quindi rifiuta duplicati o valori oltre un limite interno. Un altro converte intestazioni di fogli di calcolo in etichette legacy uniformi durante l’esportazione. Lo strumento non garantisce che il risultato sia valido per ogni compilatore COBOL o prodotto, poiché ciascuno può imporre lunghezza, carattere iniziale e parole riservate. Conservi l’originale accanto al nome generato quando serve tracciabilità.

Casi d'uso

Preparare nomi di campi legacy

Converta etichette leggibili o identificatori moderni in nomi maiuscoli con trattini per mappe di migrazione e documentazione.

Normalizzare chiavi di configurazione

Uniformi le chiavi copiate prima di inserirle in modelli, esempi, fixture o sistemi che usano una notazione marcata con trattini.

Automatizzare i nomi nei generatori

Crei risultati COBOL-CASE stabili da intestazioni di schemi o moduli durante build ed esportazioni ripetibili.

Domande frequenti

Che cos’è COBOL-CASE?

È uno stile di denominazione con parole maiuscole unite da trattini, come CUSTOMER-ACCOUNT-RECORD.

Lo strumento riconosce camelCase e PascalCase?

Sì. Separa i passaggi da minuscolo a maiuscolo e i confini tra sigle e parole prima dell’unione.

Cosa accade a punteggiatura e separatori ripetuti?

Agiscono da confini e vengono raggruppati, evitando trattini doppi, iniziali o finali.

Il risultato funziona con ogni compilatore COBOL?

Non necessariamente. Lo strumento normalizza maiuscole e separatori, ma ogni dialetto può applicare regole proprie.

Quanto costa una conversione tramite API?

Ogni richiesta API costa $0.002. La versione browser esegue gratuitamente la stessa conversione deterministica.

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

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

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/cobol-case \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"customerAccount record"}'

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

import os, requests

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

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

body := bytes.NewBufferString(`{"text":"customerAccount record"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/cobol-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": "customerAccount record"
}

Esempio di risposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "str.cobol_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

per richiesta$0.002

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.

Leggi la documentazione completa del KIT →