Text Blocks en Java 13
Anuncio:
Finalmente tenemos Text Blocks en Java 13. Java 13 ya ofrece soporte para strings multilínea. Esta nueva característica está disponible en preview para que se pueda probar y poder tener una implementación final en la próxima versión de Java. ¿Que quiere decir esto? Básicamente, no es aconsejable utilizarlo en entornos de producción, así que, aún tendremos que pelear un tiempo más con esto.
Vamos a hacer un repaso a los Strings en Java para llegar a los Bloques de Texto.
Literales String en Java
Declarar una cadena de texto en Java es tan fácil como:
String myString = "¡Esto es un String!";
Hasta aquí todo bien. Pero los Strings tienen sus limitaciones. Si tenemos una cadena muy larga o sencillamente queremos tener un string multilínea tenemos que utilizar \n y la concatenación para tener algo del tipo:
String myString = "Esta es mi cadena\n" +
"que quiero representarla \n" +
"en múltiples líneas.";
Como puedes ver puede ser difícil e incomodo de leer. Si ha esto le añadimos que tenemos que escapar los caracteres especiales se pone más complicado aún:
String myString = "Esta es mi cadena\n" +
"multilínea donde muestro un path \n" +
"aquí: \"C:\\Program Files\\Java\\jdk\"";
¿Más complicado verdad?
¿Como lo resuelven otros lenguajes?
Podemos ver que lenguajes como Scala, Groovy o Kotlin dan soporte para strings multilínea usando la triple comilla doble. Veamos un ejemplo en Kotlin:
val myText = """
Esta es mi cadena,
que estoy representando
en múltiples líneas.
Además, puedo usar caracteres como backslash \
e incluso comillas " sin tener que escapar los caracteres
"""
Como puedes ver, no solo es una cadena multilínea sino que además puedes usar caracteres especiales sin escaparlos. ¿Bien verdad?
Raw String en Java
En Java 12 se hizo una aproximación para resolver este problema con los Raw String. Esto es algo similar a lo visto anteriormente en Kotlin pero en lugar de usar triple comilla doble, se usa la comilla invertida `. La cuestión es que debes usar la misma cantidad de comillas al inicio y al final del string:
`Esta cadena usa una comilla invertida simple`
``Esta cadena usa 2 comillas invertidas simples y un carácter especial ` sin escapar``
```Puedes utilizar la cantidad de comillas invertidas que desees```
Aparentemente el problema estaba resuelto, pero los Raw String suelen dar problemas con la identación. Vamos a ver con un ejemplo para que lo puedas ver visualmente. Si tenemos el siguiente código:
public static void main(String[] args) {
String myString =
`Esto es un String
donde queremos tener
múltiples líneas.`;
System.out.println(myString);
}
Si ejecutas dicho código, tendrás la siguiente salida:
Esto es un String
donde queremos tener
múltiples líneas.
Puedes ver todas las líneas excepto la primera están identadas. Esto lo puedes resolver con los métodos align() o indent() pero hacen tedioso el uso de los Raw Strings.
String Multilínea en Java
Ahora sí, vamos a hablar de los bloques de Texto en Java 13. Los Text Blocks están en Preview Feature como te comentaba al inicio del artículo. Puedes consultar la documentación oficial de Text Blocks para conocer más como se está implementando en Java 13. Recuerda que no es aconsejable usarlo aún en entornos de producción.
Para poder usar esta nueva característica necesitas descargar el JDK 13 y asegúrarte en tu IDE de tener seleccionado Java 13. Para poder compilar necesitas habilitar las características en preview del siguiente modo:
javac --release 13 --enable-preview ...
Y para poder ejecutar tu aplicación debes correrla con:
java --enable-preview ...
Ahora sí, podemos usar Text Blocks en Java.
Text Blocks en Java 13
Creo que ha sido una buena decisión dejar de lado las comillas invertidas de los Raw Strings para adoptar el formato de Kotlin o Groovy, así que ahora los bloques de texto se delimitan con triple comilla doble. Veamos un ejemplo:
String myBlock = """
línea 1
línea 2
línea 3
"""
La declaración es igual que en Kotlin. Según el borrador de la implementación se procesa en 3 pasos:
- Se normalizan los finales de línea
- Los espacios en blanco consecutivos se eliminan
- Se escapan e interpretan los caracteres especiales
Normalización de finales de línea
Windows y Linux no interpretan de la misma forma los finales de línea, Por ejemplo Windoes usa \r y \n mientras que Linux solo usa \n. Así que lo que hace el compilador aquí es normalizar los finales de línea a \n.
Espacios en blanco. Identación.
Todos los espacios en blanco consecutivos y las tabulaciones se eliminan. Así que si quieres identar o usar más de un espacio debes usar el guión médio -. Aquí tienes un ejemplo:
String myString = """
Texto identado línea 1
-----Texto identado línea 2
-----Texto identado línea 3
Texto identado línea 4
"""
Esto dará como salida:
Texto identado línea 1
Texto identado línea 2
Texto identado línea 3
Texto identado línea 4
Caracteres especiales
En el ultimo paso, el compilador escapará e interpretará los caracteres especiales de modo que no tenemos que usar la barra invertida.
Conclusión
Como habrás podido comprobar los bloques de texto tienen muy buena pinta. Ofrecen una buen manera de trabajar con cadenas multilínea y con caracteres especiales.
Ademas, Java a adoptado la triple comilla doble que usan otros lenguajes. No se si será un estándar pero por lo menos homogeiniza los lenguajes.
Y por último, ya sabemos que se limpia el string de espacios en blanco innecesarios, cosa que hasta ahora tenemos que hacer de forma más o menos manual.
Ya conoces los Text Blocks en Java 13. Puedes aprender más en nuestra sección de Java.
Espero que te haya sido de utilidad!
