Blocchi di testo Java

1. Introduzione

In un precedente tutorial, abbiamo visto come possiamo utilizzare stringhe multilinea in qualsiasi versione di Java e senza abilitare le funzionalità di anteprima.

In questo tutorial vedremo come utilizzare la funzione di anteprima JDK 13/14 dei blocchi di testo .

2. Utilizzo

A partire da Java 13, i blocchi di testo sono disponibili come funzionalità di anteprima. I blocchi di testo iniziano con una "" " (tre virgolette doppie) seguita da uno spazio bianco opzionale e da una nuova riga. L'esempio più semplice potrebbe assomigliare a:

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

Notare che il tipo di risultato di un blocco di testo è ancora una stringa . I blocchi di testo ci forniscono solo un altro modo per scrivere stringhe letterali nel nostro codice sorgente.

All'interno dei blocchi di testo, possiamo usare liberamente le nuove righe e le virgolette senza la necessità di eseguire l'escape . Ci consente di includere frammenti letterali di HTML, JSON, SQL o qualsiasi altra cosa di cui abbiamo bisogno, in un modo più elegante e leggibile.

Nella stringa risultante , il rientro (di base) e la prima nuova riga non sono inclusi. Daremo uno sguardo alla consegna del rientro nella prossima sezione.

3. Rientro

Fortunatamente, quando si utilizzano blocchi di testo, possiamo ancora indentare correttamente il nostro codice. Per ottenere ciò, una parte del rientro viene trattata come il codice sorgente mentre un'altra parte del rientro viene vista come una parte del blocco di testo. Per fare in modo che funzioni, il compilatore controlla il rientro minimo in tutte le righe non vuote. Successivamente, il compilatore sposta il blocco di testo completo a sinistra.

Considera un blocco di testo contenente del codice HTML:

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

In questo caso, il rientro minimo è di 12 spazi. Quindi, tutti i 12 spazi a sinistra die su tutte le righe successive vengono rimossi. Proviamo questo:

@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); }

Quando abbiamo bisogno di un rientro esplicito , possiamo usare meno rientro per una riga non vuota (o l'ultima riga):

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

Inoltre, possiamo anche usare l'escape all'interno di blocchi di testo, come vedremo nella prossima sezione.

4. Fuga

All'interno di blocchi di testo, virgolette doppie e nuove righe non devono essere precedute da caratteri di escape. Tuttavia, possiamo usare l'escape per aggiungere, ad esempio, ritorni a capo ( \ r ) o tabulazioni ( \ t ) a un blocco di testo. Potremmo anche usare di nuovo "" "nel nostro blocco di testo facendo l'escape di uno dei doppi apici:

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

Tieni presente che, poiché non è necessario eseguire l'escape delle virgolette singole e delle nuove righe, è considerata una cattiva pratica evitarle.

Inoltre, nota che anche se un file di origine ha terminazioni di riga di Windows ( \ r \ n ), i blocchi di testo verranno terminati solo con newline ( \ n ) . Se abbiamo bisogno che siano presenti ritorni a capo ( \ r ), dobbiamo aggiungerli esplicitamente al blocco di testo:

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

5. Formattazione

Per facilitare la sostituzione delle variabili, è stato aggiunto un nuovo metodo che consente di chiamare il metodo String.format direttamente su un valore letterale String:

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

Tutte queste funzionalità forniscono già una funzionalità molto potente. Tuttavia, Java 14 ha incluso alcune funzionalità aggiuntive. Ne vedremo di più in seguito.

6. Nuove sequenze di escape in Java 14

La seconda anteprima della funzione Blocchi di testo aggiunge due sequenze di escape aggiuntive.

6.1. Terminatori di linea in fuga

A volte, potremmo avere lunghe righe di testo nel nostro codice sorgente che vogliamo formattare in modo leggibile. La seconda anteprima ha aggiunto una funzionalità che ci consente di farlo. Possiamo sfuggire a una nuova riga in modo che venga ignorata :

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

In realtà questa stringa letterale sarà uguale a una normale stringa non interrotta :

@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. Spazi in fuga

Il compilatore ignora tutti gli spazi finali nei blocchi di testo . Tuttavia, dalla seconda anteprima, possiamo eseguire l'escape di uno spazio utilizzando la nuova sequenza di escape \ s . Il compilatore conserverà anche eventuali spazi davanti a questo spazio sfuggito.

Diamo uno sguardo più da vicino all'impatto di uno spazio sfuggito:

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 : gli spazi nell'esempio sopra sono sostituiti con il simbolo "·" per renderli visibili.

Il compilatore rimuoverà gli spazi dalla prima riga. Tuttavia, la seconda riga viene terminata con uno spazio di escape e tutti gli spazi vengono così conservati.

7. Conclusione

In questo breve tutorial, abbiamo esaminato la funzione Blocchi di testo Java. Potrebbe non essere un punto di svolta, ma ci aiuta a scrivere codice migliore e più leggibile, il che è generalmente una buona cosa.

Come sempre, il codice sorgente completo dell'articolo è disponibile su GitHub.