ForHosting KIT · Outils pour développeurs

Convertir en COBOL-CASE

Le convertisseur COBOL-CASE transforme un texte ordinaire, des identifiants mixtes et des libellés irréguliers en une écriture uniforme et expressive : chaque mot détecté passe en majuscules et les mots voisins sont reliés par un seul tiret.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Saisissez customer account record pour obtenir CUSTOMER-ACCOUNT-RECORD. L’outil reconnaît également les limites courantes de camelCase et PascalCase, remplace la ponctuation et les séparateurs existants, et conserve les chiffres comme éléments utiles. La conversion est déterministe : une entrée identique produit toujours le même résultat dans le navigateur, un script de build, un flux API ou une chaîne de génération de configuration.

Transformez tout texte en identifiant prévisible de style COBOL

COBOL-CASE est une convention très visible composée de mots en majuscules séparés par des tirets. Elle se rencontre dans le code COBOL classique, les définitions de données historiques, les noms de commandes, les clés de configuration et les documents où les identifiants doivent ressortir immédiatement. Ce convertisseur vous évite de repérer chaque mot, d’uniformiser sa casse et de corriger les séparateurs à la main. Fournissez une phrase, un libellé copié ou un identifiant utilisant une autre convention. Le résultat contient des lettres ASCII et des chiffres regroupés en éléments majuscules, avec exactement un tiret entre deux éléments. Les espaces, underscores, tirets et signes de ponctuation servent de limites : une source incohérente devient donc une représentation stable. La réponse indique aussi le nombre de mots afin qu’un traitement automatisé puisse vérifier l’interprétation. Aucune donnée n’est stockée ni recherchée ailleurs, et le résultat reste identique à chaque exécution.

Comprenez le traitement des limites et des caractères

Le convertisseur vérifie d’abord que le texte existe, qu’il s’agit bien d’une chaîne, qu’il respecte la taille publiée et qu’il contient au moins une lettre ASCII ou un chiffre. Il détecte ensuite les limites habituelles de camelCase et PascalCase. Ainsi, customerAccount devient CUSTOMER-ACCOUNT et XMLParser devient XML-PARSER, et non XMLPARSER. Les transitions entre lettres et chiffres constituent aussi des limites : report2026Final produit REPORT-2026-FINAL. Les suites d’espaces ou de signes sont réduites à un seul séparateur et ne créent jamais de tiret doublé ou final. Chaque élément est mis en majuscules puis relié par un tiret. Cette politique volontairement stricte assure une sortie portable pour les outils anciens qui divergent sur Unicode. Les caractères accentués et symboles deviennent des séparateurs au lieu d’être translittérés silencieusement. Une entrée composée uniquement de signes ou d’espaces renvoie une erreur. Aucun réglage régional, dictionnaire ou horloge n’intervient.

Utilisez le navigateur ponctuellement et l’API pour automatiser

Pour une conversion occasionnelle, collez votre texte dans l’outil du navigateur et copiez le résultat vers un fichier source, une configuration, une note de migration ou une fixture de test. Pour les traitements réguliers, appelez l’API depuis un générateur, une chaîne d’importation, une commande d’éditeur ou un contrôle d’intégration continue. La requête comporte un seul champ texte obligatoire et coûte $0.002; le navigateur et l’API utilisent la même logique pure. Vous pouvez normaliser des noms avant de les comparer, puis refuser les doublons ou ceux qui dépassent votre propre limite. Vous pouvez aussi convertir les en-têtes d’un tableur en libellés historiques cohérents lors d’un export. L’outil ne garantit toutefois pas qu’un résultat respecte tous les compilateurs COBOL ou produits : chacun peut imposer longueur, premier caractère et mots réservés. Conservez le texte original avec le nom généré si la traçabilité est nécessaire.

Cas d’usage

Préparer des noms de champs historiques

Convertissez des libellés lisibles ou des identifiants modernes en noms majuscules avec tirets pour les correspondances de migration et la documentation.

Normaliser des clés de configuration

Uniformisez les clés copiées avant de les placer dans des modèles, exemples, fixtures ou systèmes utilisant cette notation expressive.

Automatiser les noms dans un générateur

Produisez un COBOL-CASE stable à partir d’en-têtes de schéma ou de formulaire pendant des builds et exports reproductibles.

Questions fréquentes

Qu’est-ce que COBOL-CASE ?

C’est une convention où les mots sont en majuscules et reliés par des tirets, comme CUSTOMER-ACCOUNT-RECORD.

L’outil reconnaît-il camelCase et PascalCase ?

Oui. Il sépare les passages de minuscules à majuscules et les limites entre sigles et mots avant l’assemblage.

Que deviennent la ponctuation et les séparateurs répétés ?

Ils servent de limites et sont regroupés, ce qui évite tout tiret doublé, initial ou final.

Le résultat convient-il à tous les compilateurs COBOL ?

Pas forcément. L’outil normalise la casse et les séparateurs, mais chaque dialecte peut imposer ses propres règles.

Quel est le prix d’une conversion par API ?

Chaque requête API coûte $0.002. La version navigateur applique gratuitement la même conversion déterministe.

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

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

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre 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)

Exemple de requête

{
  "text": "customerAccount record"
}

Exemple de réponse

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

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

max_chars 100000

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Consulter la documentation complète du KIT →