streamalism.org

1. Inleiding

In een eerdere tutorial hebben we gezien hoe we strings met meerdere regels kunnen gebruiken in elke Java-versie en zonder preview-functies in te schakelen.

In deze tutorial zullen we zien hoe u de JDK 13/14 preview-functie van tekstblokken gebruikt.

2. Gebruik

Sinds Java 13 zijn tekstblokken beschikbaar als preview-functie. Tekstblokken beginnen met een “”” (drie dubbele aanhalingstekens) gevolgd door optionele witruimte en een nieuwe regel. Het eenvoudigste voorbeeld zou er als volgt uit kunnen zien:

String example = "" "Voorbeeldtekst" "";

Merk op dat het resultaattype van een tekstblok nog steeds een Draad. Tekstblokken bieden ons gewoon een andere manier om te schrijven Draad literals in onze broncode.

Binnen de tekstblokken kunnen we vrij nieuwe regels en aanhalingstekens gebruiken zonder te hoeven ontsnappen. Het stelt ons in staat om letterlijke fragmenten van HTML, JSON, SQL of wat we maar nodig hebben op een meer elegante en leesbare manier op te nemen.

In het resulterende Draad, de (basis) inspringing en de eerste nieuwe regel zijn niet inbegrepen. We zullen het overhandigen van inspringen in de volgende sectie bekijken.

3. Inspringing

Gelukkig kunnen we bij het gebruik van tekstblokken onze code nog steeds correct laten inspringen. Om dat te bereiken, wordt een deel van de inspringing behandeld als de broncode, terwijl een ander deel van de inspringing wordt gezien als een onderdeel van het tekstblok. Om dit te laten werken, controleert de compiler de minimale inspringing in alle niet-lege regels. Vervolgens schuift de compiler het volledige tekstblok naar links.

Beschouw een tekstblok met wat HTML:

public String getBlockOfHtml () {return "" "voorbeeldtekst" ""; }

In dit geval is de minimale inspringing 12 spaties. Dus alle 12 velden links van en op alle volgende regels worden verwijderd. Laten we dit testen:

@Test ongeldig gegevenAnOldStyleMultilineString_whenComparing_thenEqualsTextBlock () {String verwacht = "\ n" + "\ n" + "\ n" + "voorbeeldtekst \ n" + "\ n" + ""; assertThat (subject.getBlockOfHtml ()). isEqualTo (verwacht); } @Test ongeldig gegevenAnOldStyleString_whenComparing_thenEqualsTextBlock () {String verwacht = "\ n \ n \ n voorbeeldtekst \ n \ n"; assertThat (subject.getBlockOfHtml ()) .isEqualTo (verwacht); }

Wanneer we expliciete inspringing nodig hebben, we kunnen minder inspringing gebruiken voor een niet-lege regel (of de laatste regel):

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

Bovendien kunnen we ook ontsnappen binnen tekstblokken gebruiken, zoals we in de volgende sectie zullen zien.

4. Ontsnappen

Binnen tekstblokken hoeven dubbele aanhalingstekens en nieuwe regels niet te worden ontsnapt. We kunnen echter escaping gebruiken om bijvoorbeeld regeleinde (\ r) of tabbladen (\ t) naar een tekstblok. We zouden zelfs "" "opnieuw kunnen gebruiken in ons tekstblok door te ontsnappen aan een van de dubbele aanhalingstekens:

public String getTextWithEscapes () {retourneer "" "plezier met \ n witruimte \ t \ r en andere ontsnappingen \" "" "" ";}

Houd er rekening mee dat omdat enkele dubbele aanhalingstekens en nieuwe regels niet hoeven te worden ontsnapt, het als een slechte gewoonte wordt beschouwd om eraan te ontsnappen.

Merk ook op dat zelfs als een bronbestand Windows-regeleinden heeft (\ r \ n), worden de tekstblokken alleen beëindigd met nieuwe regels (\ n). Als we wagenretouren nodig hebben (\ r) om aanwezig te zijn, moeten we ze expliciet toevoegen aan het tekstblok:

public String getTextWithCarriageReturns () {return "" "gescheiden door \ r regelaar retourneert" ""; } @Test ongeldig gegevenATextWithCarriageReturns_thenItContainsBoth () {assertThat (subject.getTextWithCarriageReturns ()) .isEqualTo ("gescheiden door \ r \ ncarriage returns"); }

5. Formatteren

Om te helpen bij het vervangen van variabelen, is een nieuwe methode toegevoegd waarmee het String.format methode rechtstreeks op een letterlijke tekenreeks:

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

Al deze functies bieden al een zeer krachtige functie. Java 14 heeft echter enkele extra functies toegevoegd. We zullen daar later meer over zien.

6. Nieuwe ontsnappingsreeksen in Java 14

Het tweede voorbeeld van de functie Tekstblokken voegt twee extra ontsnappingsreeksen toe.

6.1. Ontsnappende lijnafsluiters

Soms hebben we lange regels tekst in onze broncode die we op een leesbare manier willen opmaken. De tweede preview heeft een functie toegevoegd waarmee we dit kunnen doen. We kunnen ontsnappen aan een nieuwe regel, zodat deze wordt genegeerd:

public String getIgnoredNewLines () {return "" "Dit is een lange test die een nieuwe regel lijkt te hebben, maar die eigenlijk niet" "" heeft; }

Eigenlijk dit Draad letterlijk zal gewoon gelijk zijn aan een normale niet-onderbroken Draad:

@Test ongeldig gegevenAStringWithEscapedNewLines_thenTheResultHasNoNewLines () {String verwacht = "Dit is een lange test die een nieuwe regel lijkt te hebben, maar in feite niet"; assertThat (subject.getIgnoredNewLines ()) .isEqualTo (verwacht); }

6.2. Ontsnappende ruimtes

De compiler negeert alle volgspaties in tekstblokken. Sinds de tweede preview kunnen we echter ontsnappen aan een spatie met behulp van de nieuwe escape-reeks \ s. De compiler bewaart ook alle spaties vóór deze ontsnapte ruimte.

Laten we de impact van een ontsnapte ruimte eens nader bekijken:

public String getEscapedSpaces () {return "" "regel 1 ········ regel 2 ······· \ s" ""; } @Test ongeldig gegevenAStringWithEscapesSpaces_thenTheResultHasLinesEndingWithSpaces () {String verwacht = "regel 1 \ nregel 2 \ n"; assertThat (subject.getEscapedSpaces ()) .isEqualTo (verwacht); } 

Opmerking: de spaties in het bovenstaande voorbeeld worden vervangen door het ‘· 'symbool om ze zichtbaar te maken.

De compiler verwijdert de spaties van de eerste regel. De tweede regel wordt echter beëindigd met een ontsnapte spatie en alle spaties blijven dus behouden.

7. Conclusie

In deze korte tutorial hebben we gekeken naar de functie Java-tekstblokken. Het is misschien geen game-wisselaar, maar het helpt ons om betere en beter leesbare code te schrijven, wat over het algemeen een goede zaak is.

Zoals altijd is de volledige broncode van het artikel beschikbaar op GitHub.