Convertisseur dot.case : Générateur de noms de packages et de domaines

Transformez instantanément n'importe quel texte au format dot.case. Que vous nommiez des packages Java, créiez des noms de domaine ou organisiez des espaces de noms hiérarchiques, notre outil convertit automatiquement votre texte au format dot.case, tout en respectant les conventions de la programmation et du Web.

Évaluez-nous
0.00sur5(0 évaluations)
Caractéristiques et avantages

Convertit n'importe quel texte au format dot.case valide en temps réel : collez un chemin de package, une clé de configuration ou une phrase simple pour obtenir un identifiant en minuscules séparé par des points, prêt à être utilisé dans Java, Kotlin ou des fichiers de configuration.

Préserve la structure hiérarchique : chaque mot ou segment devient un composant séparé par un point, rendant la profondeur de l'espace de noms immédiatement visible dans la sortie.

Supprime les caractères non autorisés dans les noms de packages Java et les identifiants de domaine (barres obliques, traits d'union, traits de soulignement), produisant ainsi un chemin d'espace de noms propre sans nécessiter de post-traitement.

Prend en charge des entrées dans plusieurs formats : les expressions séparées par des espaces, le camelCase, le snake_case et le kebab-case produisent tous une sortie cohérente au format dot.case.

Produit une sortie exclusivement en minuscules, conformément à la convention de nommage des packages Java qui interdit explicitement les majuscules afin d'éviter toute ambiguïté avec les noms de classes.

Fonctionne pour la notation de domaine inversée (com.company.project), les hiérarchies de clés de propriété (app.server.port) et les noms de catégories de journaux — la même logique de conversion s'applique à ces trois contextes.

Mode d'emploi

Étape 01

Saisissez votre texte ou le nom du package

Étape 02

Copier le texte prêt pour l'espace de noms

Cas d'utilisation

Développement Java

  • Noms de paquets
  • Organisation des espaces de noms
  • Identifiants de module
  • Chemins des bibliothèques

Développement web

  • Noms de domaine
  • Domaines inversés
  • Adresses e-mail
  • Clés de configuration

Organisation du système

  • Chemins de fichiers
  • Clés de configuration
  • Entrées de registre
  • Notation d'objet
Exemples
Texte originalRésultat
com user profile
com.user.profile
org-project-main
org.project.main
web_app_config
web.app.config
domain name system
domain.name.system
Compatibilité des plateformes

Programmation

  • Java
  • Android
  • Kotlin
  • Scala

Systèmes Web

  • DNS
  • E-mail
  • Fichiers de configuration
  • Noms de paquets
Conseils de pro

Lors de la création d'un nouveau projet Java ou Kotlin, définissez le nom du package racine (com.yourcompany.projectname) à l'aide de cet outil de conversion avant d'écrire la moindre ligne de code ; en effet, renommer un package une fois que des classes ont été créées nécessite de refactoriser toutes les instructions d'importation dans l'ensemble des fichiers.

Pour les fichiers Spring Boot `application.properties` ou `application.yml`, les clés de configuration suivent une hiérarchie séparée par des points (par ex. `spring.datasource.url`, `server.port`) ; convertissez ici les descriptions de vos clés de configuration personnalisées pour obtenir des noms de propriétés correctement formatés.

Par convention, les noms des loggers Log4j et SLF4J correspondent au nom complet de la classe (fully-qualified class name) en notation pointée ; lorsque vous définissez les niveaux de journalisation par package dans votre configuration, utilisez cet outil pour formater correctement le chemin du package.

Les noms de package Android suivent la même convention que Java (format de domaine inversé avec points) ; convertissez votre identifiant d'application (com.yourname.appname) ici pour vérifier sa validité avant de le définir dans le fichier build.gradle, car les noms de package ne peuvent pas être modifiés après la publication sur le Play Store.

En JavaScript et Node.js, la notation par points est utilisée pour les clés de configuration imbriquées dans des bibliothèques telles que dotenv-expand, nconf et convict ; utilisez cet outil pour formater les chemins de clés de configuration imbriquées avant de rédiger votre schéma de configuration.

Meilleures pratiques

Commencez toujours les noms de packages Java par le nom de domaine inversé de votre organisation (com.yourcompany) plutôt que par un préfixe générique tel que « app » ou « util » ; les préfixes génériques entraînent des conflits entre projets et rendent la résolution des dépendances ambiguë dans les builds multi-modules.

Veillez à ce que chaque segment séparé par un point soit constitué d'un mot unique en minuscules ne commençant pas par un chiffre ; bien que les compilateurs Java acceptent des chiffres au sein des segments, de nombreux outils de build et fonctionnalités de refactorisation des IDE présentent un comportement imprévisible avec des noms de packages commençant par un chiffre.

Évitez d'utiliser des mots réservés de Java (class, interface, package, import) comme noms de segments : bien que la JVM en autorise certains dans les identifiants de packages, les IDE et les outils d'analyse statique (linters) les signalent comme étant sources de confusion, et certains outils de build les rejettent purement et simplement.

Pour les hiérarchies de clés de configuration, veillez à une profondeur cohérente : mélanger des clés plates (database) et des clés imbriquées (app.server.database.pool.maxSize) dans un même fichier de configuration crée un modèle mental incohérent qui complique les audits de configuration.

Lors de la publication d'une application Android, finalisez le nom du package avant sa première mise en ligne sur le Play Store : contrairement à la plupart des autres identifiants d'un projet, le nom du package Android est définitivement associé à la fiche de votre application et ne peut être modifié sans créer une toute nouvelle entrée sur le store.

FAQ

Foire aux questions

Trouvez des réponses aux questions fréquentes sur nos outils et services.

Guide approfondi

Comprendre dot.case

Le format « dot.case » est la plus ancienne des conventions de nommage courantes en programmation encore activement utilisées au quotidien. Il est apparu dans les premiers systèmes Lisp et les fichiers de configuration Unix avant d'être officialisé comme convention obligatoire pour le nommage des packages dans Java 1.0, en 1996. La spécification du langage Java impose que les noms de packages soient constitués d'identifiants en minuscules séparés par des points, dans l'ordre inverse de celui des noms de domaine (par exemple, `com.company.product`), afin de garantir une unicité globale à travers tout l'écosystème. Cette exigence a ancré le format « dot.case » dans la culture générale des développeurs comme aucune autre convention ne l'avait fait, puisque chaque fichier Java débute par une déclaration de package.

Ce convertisseur est principalement utilisé au quotidien pour le développement en Java et Kotlin. Lors de la création d'un nouveau module, d'une bibliothèque ou d'une application Android, un identifiant de package est nécessaire avant de pouvoir créer la première classe. Les chefs de produit et les designers transmettent les noms de projets en langage courant (par exemple, « User Authentication Service » ou « Payment Gateway Client ») ; cet outil les convertit en segments de chemin de package valides, auxquels vous pouvez ajouter en préfixe le nom de domaine inversé de votre organisation. Bien que la conversion soit suffisamment simple pour être souvent effectuée mentalement par les développeurs, une conversion manuelle de noms composés de plusieurs mots peut entraîner des incohérences : « auth service » pourrait ainsi devenir com.company.authservice, com.company.auth_service ou com.company.authService, selon la personne qui effectue la saisie.

Un second cas d'usage concerne Spring Boot et la configuration générale de la JVM. Le système de configuration externalisée de Spring utilise largement des hiérarchies de clés séparées par des points : `spring.datasource.url`, `spring.jpa.hibernate.ddl-auto`, `management.endpoints.web.exposure.include`. Lorsque vous définissez vos propres propriétés de configuration spécifiques à l'application, le respect des conventions de Spring donne à vos clés un caractère natif au sein du framework et garantit leur compatibilité avec les mécanismes de liaison de configuration (*binding*) et les règles de liaison souple (*relaxed binding*) de Spring Boot.

En dehors de l'écosystème JVM, la notation « dot.case » apparaît dans : les chaînes de propriétés d'objets JavaScript utilisées comme clés de configuration (webpack `resolve.alias`, eslint `rules.no-unused-vars`), la configuration de la journalisation en Python (`logging.getLogger('myapp.services.auth')`), les hiérarchies de configuration YAML que les bibliothèques de configuration aplatissent en utilisant des points comme séparateurs, ainsi que les noms d'hôtes DNS où chaque étiquette constitue un composant séparé par un point. L'outil de conversion est utile dans tous ces contextes, même en l'absence de packages Java.

L'approche manuelle est simple pour les noms courts, mais source d'erreurs à plus grande échelle : tout mettre en minuscules, supprimer les caractères non alphanumériques et assembler le tout avec des points. Les cas particuliers qui piègent souvent les développeurs sont les séparateurs consécutifs (espaces multiples ou mélange de traits de soulignement et de traits d'union générant des points doubles), les chiffres en début de segment (invalides pour les packages Java) et l'inclusion accidentelle du TLD du projet comme simple segment au lieu du nom de domaine inversé complet. Cet outil normalise tous ces cas de figure.

Des outils pour tous les besoins