ForHosting KIT · Texte et IA

Convertir en CONSTANT_CASE

hello world devient HELLO_WORLD et get-user-profile devient GET_USER_PROFILE : chaque mot en majuscules, relié par des traits de soulignement, sans espaces, tirets ni points. C'est la forme habituelle des variables d'environnement, des constantes et des indicateurs de fonctionnalité. Gratuit dans votre navigateur.

  • Gratuit
  • Fonctionne dans votre navigateur
  • Sans inscription
  • Vos données restent sur votre appareil
Utilisez-le depuis WebAPIE-mailTelegramApp bientôt
Si vous saisissez
Texte
hello world
Vous obtenez
Texte
HELLO_WORLD
Original
hello world
Longueur
11
Mots
2

Cet outil de conversion en CONSTANT_CASE prend une phrase non vide et renvoie un identifiant SCREAMING_SNAKE_CASE unique : chaque mot est mis en majuscules et les mots sont joints par des traits de soulignement, sans espaces, traits d'union, ou points restants dans le résultat. CONSTANT_CASE est la forme quotidienne des variables d'environnement, des constantes de compilation, des clés de configuration, des indicateurs de fonctionnalité, et de nombreux guides de style de langage qui réservent les MAJUSCULES aux valeurs qui doivent rester stables entre les builds. Fournissez-lui des titres espacés, des propriétés camelCase, des racines de classes CSS kebab-case, des fragments de paquets pointés, ou une ponctuation mixte, et le moteur reconstruit une chaîne CONSTANT_CASE déterministe unique. Rien n'est deviné par un modèle, rien n'est récupéré via le réseau, et rien ne dépend de l'horloge ou de graines aléatoires.

Où la conversion CONSTANT_CASE s'inscrit dans l'étude, l'édition et les logiciels

Les enseignants peuvent pré-générer des corrigés qui montrent la forme CONSTANT_CASE attendue sans faire confiance à des macros de tableur opaques qui changent les règles de locale en cours de fichier. Les développeurs backend et DevOps utilisent CONSTANT_CASE pour les clés d'environnement de processus, les variables Docker Compose, les conventions de nommage des secrets Kubernetes, les identifiants d'indicateurs de fonctionnalité, et les constantes de compilation dans les guides de style C, Go, et Rust.

Les équipes d'intégration convertissent des titres de colonnes CSV hérités en clés SCREAMING_SNAKE_CASE stables avant que les chargeurs de configuration et les gestionnaires de secrets ne figent le contrat. Les applications mobiles et multiplateformes associent des étiquettes humaines à des identifiants de constante partagés qui relient des modules natifs et des ponts JavaScript. Les équipes support et opérations collent des sujets de tickets bruyants ou des noms de code de version en CONSTANT_CASE afin que les tableaux de bord et les runbooks partagent une seule forme d'identifiant.

Associez-le à des outils de camelCase, de majuscules, ou d'encodage lorsque vous construisez un petit laboratoire d'utilitaires de texte gratuits et déterministes pour les formulaires, la préparation d'environnement, et l'hygiène des données.

Normaliser les clés d'environnement et de configuration

Transformez des en-têtes espacés, des propriétés camelCase, et des étiquettes kebab en clés CONSTANT_CASE stables pour les fichiers d'environnement, Docker Compose, et les gestionnaires de secrets.

Indicateurs de fonctionnalité et constantes de compilation

Convertissez des phrases humaines en noms d'indicateurs CONSTANT_CASE et en constantes de niveau langage avant de câbler des backends, la CI, ou des modules natifs.

Combien coûte l'outil de conversion en CONSTANT_CASE ?

Il est gratuit dans votre navigateur sur cette page.

Que se passe-t-il si j'envoie une chaîne vide ?

Un texte vide n'est pas une conversion valide ; fournissez une phrase non vide avec au moins un caractère alphanumérique.

Quels séparateurs deviennent des traits de soulignement ?

Les espaces, traits d'union, points, et autres séquences non alphanumériques sont traités comme des ruptures de mot. Les mots sont mis en majuscules et joints par des traits de soulignement simples ; les traits de soulignement existants agissent déjà comme des ruptures.

CONSTANT_CASE est-il identique à camelCase ?

Non. camelCase met le premier mot en minuscule et retire les séparateurs. CONSTANT_CASE met chaque mot en majuscules et les joint par des traits de soulignement (SCREAMING_SNAKE_CASE).

Le résultat est-il le même à chaque fois pour la même entrée ?

Oui. La transformation est pure et déterministe : sans réseau, sans aléatoire, et sans horloge. La même phrase produit toujours la même chaîne CONSTANT_CASE.

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.

POSThttps://api.kit.forhosting.com/str/constant-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é.

curl -X POST https://api.kit.forhosting.com/str/constant-case \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"hello world"}'
{
  "text": "hello world"
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "str.constant_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.

par requête$0.002

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

max_chars100000
HTTPCodeSignification
401unauthorizedClé API absente ou invalide : vérifiez l’en-tête Authorization.
402insufficient_balanceSolde insuffisant : rechargez votre compte pour lancer cette tâche.
404unknown_typeType de tâche inconnu : vérifiez le champ type de votre requête.
429rate_limitedTrop de requêtes : ralentissez la cadence, puis réessayez.

L'entrée vide et les chaînes composées uniquement de séparateurs échouent avec une erreur invalid_input claire afin qu'un formulaire vide ne puisse pas ressembler à une conversion réussie. Utilisez-le gratuitement dans le navigateur pour les exercices de nommage, la préparation de fichiers d'environnement, et le nettoyage de données, ou appelez l'API à $0.002 par requête réussie lorsque la CI, les pipelines de formulaires, ou les démonstrations pédagogiques ont besoin du même résultat CONSTANT_CASE à chaque fois.

Ce que signifie la conversion CONSTANT_CASE et ce que contient la réponse

La conversion CONSTANT_CASE transforme une phrase à plusieurs mots en un identifiant unique où chaque lettre est en majuscule et les mots sont séparés par des traits de soulignement simples, sans espaces ni autre ponctuation entre eux. La transformation n'est pas du camelCase (qui laisserait le premier mot en minuscule et retirerait les séparateurs), pas du PascalCase, pas du kebab-case, et pas un slug qui garde les traits d'union : seule l'orthographe SCREAMING_SNAKE_CASE demeure. Il n'y a pas de mode partiel qui met en majuscules une chaîne déjà jointe sans re-tokeniser, pas de règles de titre spécifiques à une locale, et pas de coercition silencieuse de null en succès vide. En pratique, hello world devient HELLO_WORLD, user_id devient USER_ID, get-user-profile devient GET_USER_PROFILE, et un fragment pointé tel que order.line.item devient ORDER_LINE_ITEM. Ce calculateur renvoie cinq champs stables : text contient le résultat CONSTANT_CASE que vous copierez dans le code, un fichier d'environnement, ou un schéma ; original reprend la chaîne d'entrée exacte afin que vous puissiez auditer ce qui a été transformé ; length indique le nombre de caractères du résultat ; words compte combien de jetons ont été joints ; et method est l'étiquette fixe to_constant_case pour les journaux et les pipelines multi-outils. Le moteur construit soit une chaîne CONSTANT_CASE complète dans la longueur prise en charge, soit rejette la requête avec invalid_input. Les cas rejetés incluent un champ text manquant, une valeur null, une chaîne vide, des charges utiles composées uniquement d'espaces ou de séparateurs qui ne laissent aucun jeton alphanumérique, des objets et tableaux qui ne sont pas du texte brut, et toute charge utile plus longue que le nombre maximum de caractères documenté. Si vous avez besoin de camelCase, minuscules uniquement, génération de slug, ou PascalCase, utilisez ces outils dédiés ; cette page répond uniquement à la conversion phrase-vers-CONSTANT_CASE avec une sortie stable adaptée aux fiches d'exercices, aux tests unitaires et aux clients d'API qui ne doivent pas inventer de règles de nommage.

Comment le champ text est lu et comment le résultat reste reproductible

La valeur doit être une chaîne non vide ; les nombres finis et les bigints sont d'abord convertis en chaîne afin qu'un code numérique nu devienne quand même un jeton CONSTANT_CASE après conversion en chiffres décimaux. Les espaces initiaux et finaux sont retirés avant la tokenisation ; les séquences internes d'espaces, de traits de soulignement, de traits d'union, de points, et d'autres caractères non alphanumériques agissent comme des ruptures de mot et deviennent des traits de soulignement simples dans la sortie uniquement entre les jetons. Les limites camelCase ou PascalCase existantes sont développées afin que XMLHttp Request et getUserID se découpent tous deux en mots sensés avant le réassemblage. Chaque jeton est entièrement mis en majuscules, ce qui garde helloWorld, HELLO_WORLD, et hello-world sur le même résultat HELLO_WORLD après tokenisation. Le champ préféré est text, mais les alias input, string, value, content, s, et phrase sont acceptés afin que chaînes de requête, tableurs, et formulaires typés puissent réutiliser le même contrat sans renommer de colonnes. Les booléens, objets simples, et tableaux sont rejetés avec un message clair afin qu'un corps JSON erroné ne devienne pas le mot TRUE ou un dump d'objet inutile. La chaîne vide est toujours invalid_input : la promesse produit est de convertir une phrase, pas d'inventer un succès vide. La longueur est plafonnée à cent mille caractères afin qu'un collage incontrôlé ne puisse pas monopoliser un Worker ; des charges utiles plus longues échouent avec un message de limite explicite plutôt qu'une coupure silencieuse tronquée. Associez l'exécution gratuite dans le navigateur sur cette page à l'API payante lorsque vous avez besoin du résultat CONSTANT_CASE identique au sein d'un pipeline automatisé sans déployer vos propres utilitaires de chaîne.

Où la conversion CONSTANT_CASE s'inscrit dans l'étude, l'édition et les logiciels

Les élèves rencontrent CONSTANT_CASE lorsqu'un exercice de programmation exige des noms de variables d'environnement conformes à un guide de style, lorsqu'un laboratoire de saisie de données nettoie des en-têtes de tableur en clés de configuration, ou lorsqu'une classe de systèmes renomme des champs API camelCase en jetons MAJUSCULES sûrs pour le shell. Sur cette page, le travail s'exécute entièrement dans votre navigateur ; via l'API, chaque conversion réussie coûte $0.002, la validation échouée n'est pas facturée, et rien n'est stocké après le retour de la réponse. Cette séparation — exploration interactive gratuite et API payante identique — correspond au reste du catalogue KIT de niveau A, et vous permet de passer d'une démonstration en classe à un pipeline automatisé sans changer le résultat de chaîne.

Fixtures de constantes déterministes

Générez des identifiants SCREAMING_SNAKE_CASE reproductibles pour les tests unitaires, les fichiers de référence, et les assertions de CI sur le code de nommage et de transformation.

Consulter la documentation complète du KIT →