Convertidor dot.case: Generador de nombres de paquetes y dominios
Transforma al instante cualquier texto al formato limpio dot.case. Ya sea que estés nombrando paquetes de Java, creando nombres de dominio u organizando espacios de nombres jerárquicos, nuestra herramienta convierte automáticamente tu texto al formato dot.case correcto, respetando las convenciones de programación y web.
Convierte cualquier texto al formato dot.case válido en tiempo real: pega una ruta de paquete, una clave de configuración o una frase cualquiera y obtén un identificador en minúsculas separado por puntos, listo para Java, Kotlin o archivos de configuración.
Preserva la estructura jerárquica: cada palabra o segmento se convierte en un componente separado por puntos, lo que hace que la profundidad del espacio de nombres sea inmediatamente visible en la salida.
Elimina los caracteres no permitidos en nombres de paquetes Java e identificadores de dominio —barras inclinadas, guiones y guiones bajos—, de modo que el resultado es una ruta de espacio de nombres limpia que no requiere procesamiento posterior.
Gestiona entradas en múltiples formatos: frases separadas por espacios, camelCase, snake_case y kebab-case; todos ellos generan una salida consistente en formato dot.case.
Genera una salida exclusivamente en minúsculas, cumpliendo con la convención de nomenclatura de paquetes de Java que prohíbe explícitamente las letras mayúsculas para evitar ambigüedades con los nombres de las clases.
Funciona con la notación de dominio invertido (com.company.project), las jerarquías de claves de propiedad (app.server.port) y los nombres de categorías de registro; la misma lógica de conversión se aplica a los tres contextos.
Cómo usarlo
Introduce tu texto o el nombre del paquete
Copiar texto listo para el espacio de nombres
Desarrollo en Java
- Nombres de paquetes
- Organización de espacios de nombres
- Identificadores de módulo
- Rutas de biblioteca
Desarrollo web
- Nombres de dominio
- Dominios inversos
- Direcciones de correo electrónico
- Claves de configuración
Organización del sistema
- Rutas de archivo
- Claves de configuración
- Entradas del registro
- Notación de objetos
| Texto original | Resultado |
|---|---|
com user profile | com.user.profile |
org-project-main | org.project.main |
web_app_config | web.app.config |
domain name system | domain.name.system |
Programación
- Java
- Android
- Kotlin
- Scala
Sistemas web
- DNS
- Correo electrónico
- Archivos de configuración
- Nombres de paquetes
Al crear un nuevo proyecto en Java o Kotlin, define el nombre del paquete raíz (com.tuempresa.nombreproyecto) utilizando este conversor antes de escribir código; cambiar el nombre de un paquete una vez que ya existen clases requiere refactorizar todas las sentencias de importación en todos los archivos.
En los archivos `application.properties` o `application.yml` de Spring Boot, las claves de configuración siguen jerarquías separadas por puntos (p. ej., `spring.datasource.url`, `server.port`); convierte aquí las descripciones de tus claves de configuración personalizadas para obtener nombres de propiedad con el formato correcto.
Por convención, los nombres de los registradores (loggers) de Log4j y SLF4J corresponden al nombre completo de la clase en formato `dot.case`; al definir niveles de registro por paquete en la configuración, utilice esta herramienta para formatear correctamente la ruta del paquete.
Los nombres de paquete de Android siguen la misma convención de dominio invertido (formato `punto.caso`) que Java; convierte aquí el identificador de tu aplicación (com.yourname.appname) para verificar que sea válido antes de establecerlo en `build.gradle`, ya que los nombres de paquete no se pueden cambiar una vez publicados en Play Store.
En JavaScript y Node.js, se utiliza la notación de puntos para las claves de configuración anidadas en bibliotecas como dotenv-expand, nconf y convict; utiliza esta herramienta para dar formato a las rutas de las claves de configuración anidadas antes de redactar tu esquema de configuración.
Empieza siempre los nombres de los paquetes Java con el dominio invertido de tu organización (com.tuempresa) en lugar de con un prefijo genérico como "app" o "util"; los nombres genéricos provocan conflictos entre proyectos y generan ambigüedad en la resolución de dependencias en compilaciones de múltiples módulos.
Mantén cada segmento separado por puntos como una única palabra en minúsculas y sin números al inicio; aunque los compiladores de Java aceptan dígitos dentro de los segmentos, muchas herramientas de compilación y funciones de refactorización de los IDE presentan comportamientos inesperados con nombres de paquetes que comienzan por un número.
Evita utilizar palabras reservadas de Java (class, interface, package, import) como nombres de segmentos; aunque la JVM permite algunas de ellas en identificadores de paquetes, los IDE y las herramientas de análisis estático (linters) las señalan como confusas, y algunas herramientas de compilación las rechazan directamente.
En las jerarquías de claves de configuración, mantenga una profundidad uniforme: mezclar claves planas (database) con claves de mayor profundidad (app.server.database.pool.maxSize) en un mismo archivo de configuración genera un modelo mental incoherente que dificulta las auditorías de configuración.
Al publicar una aplicación para Android, define el nombre del paquete antes del primer lanzamiento en Play Store; a diferencia de la mayoría de los demás identificadores de un proyecto, el nombre del paquete de Android queda asociado permanentemente a la ficha de la aplicación y no puede cambiarse sin crear una entrada totalmente nueva en la tienda.
Preguntas frecuentes
Encuentra respuestas a las preguntas más comunes sobre nuestras herramientas y servicios.
Entender dot.case
El formato *dot.case* es la más antigua de las convenciones de nomenclatura de programación habituales que todavía se utilizan a diario. Surgió en los primeros sistemas Lisp y en archivos de configuración de Unix antes de formalizarse como la convención obligatoria para nombrar paquetes en Java 1.0, en 1996. La especificación del lenguaje Java exige que los nombres de los paquetes sean identificadores en minúsculas separados por puntos y dispuestos en orden de dominio inverso —por ejemplo, `com.company.product`— para garantizar su unicidad global en todo el ecosistema. Este requisito consolidó el uso de *dot.case* en la cultura general de los desarrolladores como ninguna otra convención lo había hecho, dado que todos los archivos de Java comienzan con una declaración de paquete.
El principal caso de uso diario de este conversor es el desarrollo en Java y Kotlin. Al iniciar un nuevo módulo, biblioteca o aplicación para Android, se requiere un identificador de paquete antes de poder crear la primera clase. Los gestores de producto y los diseñadores suelen proporcionar los nombres de los proyectos en lenguaje natural (por ejemplo, "User Authentication Service" o "Payment Gateway Client"); esta herramienta los convierte en segmentos de ruta de paquete válidos a los que se puede anteponer el dominio invertido de la organización. Aunque la conversión es lo suficientemente sencilla como para que los desarrolladores la realicen a menudo mentalmente, hacerlo de forma manual con nombres compuestos por varias palabras puede generar inconsistencias: "auth service" podría convertirse en `com.company.authservice`, `com.company.auth_service` o `com.company.authService`, dependiendo de quién realice la escritura.
Un segundo caso de uso es la configuración de Spring Boot y de la JVM en general. El sistema de configuración externalizada de Spring utiliza ampliamente jerarquías de claves separadas por puntos: `spring.datasource.url`, `spring.jpa.hibernate.ddl-auto`, `management.endpoints.web.exposure.include`. Al definir propiedades de configuración específicas para tu aplicación, seguir la convención de Spring hace que tus claves se integren de forma nativa en el framework y garantiza la compatibilidad con los mecanismos de vinculación de configuración y las reglas de vinculación flexible (*relaxed binding*) de Spring Boot.
Fuera del entorno de la JVM, el formato *dot.case* aparece en: cadenas de propiedades de objetos JavaScript utilizadas como claves de configuración (como `webpack resolve.alias` o `eslint rules.no-unused-vars`), la configuración de registro (*logging*) en Python (por ejemplo, `logging.getLogger('myapp.services.auth')`), jerarquías de configuración YAML que las bibliotecas aplanan utilizando puntos como separadores, y nombres de host DNS donde cada etiqueta es un componente separado por puntos. El conversor resulta útil en todos estos contextos, incluso cuando no intervienen paquetes de Java.
La alternativa manual es sencilla para nombres cortos, pero propensa a errores cuando se escala: convertir todo a minúsculas, eliminar caracteres no alfanuméricos y unir los elementos con puntos. Los casos límite que suelen causar problemas a los desarrolladores son los separadores consecutivos (varios espacios o una mezcla de guiones bajos y guiones normales que generan puntos dobles), los dígitos al inicio de un segmento (inválidos en los paquetes de Java) y la inclusión accidental del TLD del proyecto como un segmento en lugar del dominio completo en orden inverso. Esta herramienta normaliza todos esos casos.