Durante mucho tiempo, trabajar con texto multilínea en Java significó llenar el código de `\n`, concatenaciones y escapes:
String json = "{\n" +
" \"name\": \"Emanuel\",\n" +
" \"language\": \"Java\"\n" +
"}";
A partir de Java 15, esto cambió con JEP 378: Text Blocks.
Ahora podemos escribir:
String json = """
{
"name": "Emanuel",
"language": "Java"
}
""";
Mucho más parecido al texto que realmente queremos representar.
Pero no son simplemente strings multilínea
Lo interesante de los Text Blocks está en cómo Java decidió tratar la indentación y los espacios.
Por ejemplo:
String text = """
Hello
World
""";
El resultado es:
Hello
World
La indentación que utilizamos para mantener prolijo nuestro código Java no pasa automáticamente al String.
Java distingue entre el whitespace incidental, necesario para organizar el código fuente, y el whitespace que realmente forma parte del contenido.
Esto permite escribir código legible sin terminar con espacios innecesarios dentro del texto.
¿Y si realmente necesito espacios? Podemos utilizar `\s`.
String text = """
Hello\s
World
""";
Ese \s representa un espacio que queremos conservar explícitamente.
También existe una particularidad interesante con \:
String text = """
Hello \
World
""";
Aquí el \ evita que el salto de línea del código fuente se convierta en un salto de línea del String.
El resultado es:
Hello World
Es decir, los Text Blocks no solamente agregan una nueva sintaxis: agregan herramientas para controlar exactamente cómo se transforma el código fuente en el contenido del String.
Uno de los casos donde más se nota la diferencia es al trabajar con formatos que naturalmente ocupan varias líneas.
String json = """
{
"name": "Emanuel",
"language": "Java",
"version": 25
}
""";
String sql = """
SELECT id, name
FROM users
WHERE active = true
ORDER BY name
""";
String html = """
<html>
<body>
<h1>Hello Java</h1>
</body>
</html>
""";
El código se parece mucho más al documento que estamos representando.
Y podemos combinarlos con String.formatted():
String message = """
Hello %s!
Welcome to %s.
""".formatted("Emanuel", "Java");
Esto resulta especialmente cómodo para generar pequeños fragmentos de texto estructurado.
Text Blocks fueron introducidos como preview en Java 13, tuvieron una segunda preview en Java 14 y finalmente se convirtieron en una feature estándar en Java 15, mediante JEP 378.
Y hay algo interesante detrás de esta evolución.
La feature parece pequeña, pero obligó a Java a resolver cuestiones bastante delicadas:
- ¿Qué espacios forman parte del texto?
- ¿Qué indentación pertenece al código y cuál al contenido?
- ¿Cómo representar un salto de línea?
- ¿Cómo conservar espacios al final?
- ¿Cómo evitar que escribir un texto multilínea produzca un String lleno de whitespace accidental?
Por eso, los Text Blocks son un buen ejemplo de algo que parece ser simplemente syntax sugar, pero que en realidad requiere bastante diseño del lenguaje.
Los Text Blocks permiten escribir strings multilínea de una manera mucho más natural:
String text = """
Este es un texto
de varias líneas
escrito directamente
en Java.
""";
Pero lo importante de JEP 378 no es solamente el """.
Es la decisión de que la representación visual del texto en el código fuente y el contenido real del String no tienen por qué ser exactamente lo mismo.
Y ahí está probablemente la parte más interesante de esta feature: Java agregó una sintaxis para escribir texto como texto, sin abandonar el control preciso sobre whitespace y terminadores de línea.
No hay comentarios.:
Publicar un comentario