Bloques de texto Java

1. Introducción

En un tutorial anterior, vimos cómo podemos usar cadenas de varias líneas en cualquier versión de Java y sin habilitar las funciones de vista previa.

En este tutorial, veremos cómo usar la función de vista previa JDK 13/14 de bloques de texto .

2. Uso

Desde Java 13, los bloques de texto están disponibles como función de vista previa. Los bloques de texto comienzan con un “” ” (tres comillas dobles) seguido de un espacio en blanco opcional y una nueva línea. El ejemplo más simple podría verse así:

String example = """ Example text""";

Tenga en cuenta que el tipo de resultado de un bloque de texto sigue siendo una cadena . Los bloques de texto simplemente nos proporcionan otra forma de escribir literales de cadena en nuestro código fuente.

Dentro de los bloques de texto, podemos utilizar libremente nuevas líneas y comillas sin necesidad de escapar . Nos permite incluir fragmentos literales de HTML, JSON, SQL, o lo que necesitemos, de una manera más elegante y legible.

En la cadena resultante , la sangría (base) y la primera línea nueva no se incluyen. Echaremos un vistazo al manejo de la sangría en la siguiente sección.

3. Sangría

Afortunadamente, cuando usamos bloques de texto, aún podemos sangrar nuestro código correctamente. Para lograr eso, parte de la sangría se trata como el código fuente, mientras que otra parte de la sangría se ve como parte del bloque de texto. Para que esto funcione, el compilador comprueba la sangría mínima en todas las líneas no vacías. A continuación, el compilador desplaza el bloque de texto completo hacia la izquierda.

Considere un bloque de texto que contiene algo de HTML:

public String getBlockOfHtml() { return """   example text  """; }

En este caso, la sangría mínima es de 12 espacios. Por lo tanto, los 12 espacios a la izquierda dey en todas las líneas siguientes se eliminan. Probemos esto:

@Test void givenAnOldStyleMultilineString_whenComparing_thenEqualsTextBlock() { String expected = "\n" + "\n" + " \n" + " example text\n" + " \n" + ""; assertThat(subject.getBlockOfHtml()).isEqualTo(expected); } @Test void givenAnOldStyleString_whenComparing_thenEqualsTextBlock() { String expected = "\n\n \n example text\n \n"; assertThat(subject.getBlockOfHtml()) .isEqualTo(expected); }

Cuando necesitamos una sangría explícita , podemos usar menos sangría para una línea no vacía (o la última línea):

public String getNonStandardIndent() { return """ Indent """; } @Test void givenAnIndentedString_thenMatchesIndentedOldStyle() { assertThat(subject.getNonStandardIndent()) .isEqualTo(" Indent\n"); }

Además, también podemos utilizar el escape dentro de bloques de texto, como veremos en la siguiente sección.

4. Escapar

Dentro de los bloques de texto, las comillas dobles y las nuevas líneas no tienen que escaparse. Sin embargo, podemos usar el escape para agregar, por ejemplo, retornos de carro ( \ r ) o tabulaciones ( \ t ) a un bloque de texto. Incluso podríamos usar “” ”nuevamente en nuestro bloque de texto escapando una de las comillas dobles:

public String getTextWithEscapes() { return """ fun with\n whitespace\t\r and other escapes \""" """; }

Tenga en cuenta que debido a que las comillas dobles simples y las nuevas líneas no tienen que escaparse, se considera una mala práctica hacerlo.

Además, tenga en cuenta que incluso si un archivo de origen tiene finales de línea de Windows ( \ r \ n ), los bloques de texto solo terminarán con nuevas líneas ( \ n ) . Si necesitamos que los retornos de carro ( \ r ) estén presentes, tenemos que agregarlos explícitamente al bloque de texto:

public String getTextWithCarriageReturns() { return """ separated with\r carriage returns"""; } @Test void givenATextWithCarriageReturns_thenItContainsBoth() { assertThat(subject.getTextWithCarriageReturns()) .isEqualTo("separated with\r\ncarriage returns"); }

5. Formateo

Para ayudar con la sustitución de variables, se agregó un nuevo método que permite llamar al método String.format directamente en un literal String:

public String getFormattedText(String parameter) { return """ Some parameter: %s """.formatted(parameter); }

Todas estas características ya brindan una característica muy poderosa. Sin embargo, Java 14 ha incluido algunas características adicionales. Veremos más sobre eso a continuación.

6. Nuevas secuencias de escape en Java 14

La segunda vista previa de la función Bloques de texto agrega dos secuencias de escape adicionales.

6.1. Terminadores de línea de escape

A veces, es posible que tengamos largas líneas de texto en nuestro código fuente que queremos formatear de una manera legible. La segunda vista previa agregó una función que nos permite hacer esto. Podemos escapar de una nueva línea para que se ignore :

public String getIgnoredNewLines() { return """ This is a long test which looks to \ have a newline but actually does not"""; }

En realidad, este literal de cadena será igual a una cadena normal no interrumpida :

@Test void givenAStringWithEscapedNewLines_thenTheResultHasNoNewLines() { String expected = "This is a long test which looks to have a newline but actually does not"; assertThat(subject.getIgnoredNewLines()) .isEqualTo(expected); }

6.2. Espacios de escape

El compilador ignora todos los espacios finales en los bloques de texto . Sin embargo, desde la segunda vista previa, podemos escapar de un espacio usando la nueva secuencia de escape \ s . El compilador también conservará los espacios frente a este espacio de escape.

Echemos un vistazo más de cerca al impacto de un espacio de escape:

public String getEscapedSpaces() { return """ line 1······· line 2·······\s """; } @Test void givenAStringWithEscapesSpaces_thenTheResultHasLinesEndingWithSpaces() { String expected = "line 1\nline 2 \n"; assertThat(subject.getEscapedSpaces()) .isEqualTo(expected); } 

Nota : los espacios en el ejemplo anterior se reemplazan con el símbolo '·' para hacerlos visibles.

El compilador eliminará los espacios de la primera línea. Sin embargo, la segunda línea se termina con un espacio de escape y, por lo tanto, se conservan todos los espacios.

7. Conclusión

En este breve tutorial, analizamos la función de bloques de texto de Java. Puede que no sea un cambio de juego, pero nos ayuda a escribir un código mejor y más legible, lo que generalmente es algo bueno.

Como siempre, el código fuente completo del artículo está disponible en GitHub.