streamalism.org

1. Oversikt

I denne opplæringen vil vi se nærmere på flere typer strenger i Groovy, inkludert enkelt siterte, dobbelt siterte, trippel siterte og slashy strenger.

Vi vil også utforske Groovys strengstøtte for spesialtegn, multi-line, regex, escaping og variabel interpolasjon.

2. Forbedring java.lang.Streng

Det er sannsynligvis godt å begynne med å si at siden Groovy er basert på Java, har den alle Java-er String funksjoner som sammenføyning, String API og de iboende fordelene med String konstant basseng på grunn av det.

La oss først se hvordan Groovy utvider noen av disse grunnleggende.

2.1. String sammenføyning

Strengsammenkobling er bare en kombinasjon av to strenger:

def first = 'first' def second = "second" def concatenation = first + second assertEquals ('firstsecond', concatenation)

Hvor Groovy bygger på dette er med sine flere andre strengetyper, som vi tar en titt på med et øyeblikk. Merk at vi kan sammenkoble hver type om hverandre.

2.2. String Interpolation

Nå tilbyr Java noen veldig grunnleggende maler gjennom printf, men Groovy går dypere og tilbyr strenginterpolasjon, prosessen med å mal strenger med variabler:

def name = "Kacper" def result = "Hello $ {name}!" assertEquals ("Hello Kacper!", result.toString ())

Mens Groovy støtter sammenkobling for alle strengtyper, det gir bare interpolering for visse typer.

2.3. G-streng

Men skjult i dette eksemplet er en liten rynke - hvorfor ringer vi toString ()?

Faktisk, resultat er ikke av typen String, selv om det ser ut som det.

Fordi det String klasse er endelig, Groovys strengklasse som støtter interpolering, G-streng, underklasser det ikke. Med andre ord, for Groovy å tilby denne forbedringen, den har sin egen strengeklasse, G-streng, som ikke kan strekke seg fra String.

Enkelt sagt, hvis vi gjorde det:

assertEquals ("Hello Kacper!", resultat)

dette påkaller assertEquals (Object, Object), og vi får:

java.lang.AssertionError: forventet: java.lang.String men var: org.codehaus.groovy.runtime.GStringImpl Forventet: java.lang.String Faktisk: org.codehaus.groovy.runtime.GStringImpl

3. Enkelt sitert streng

Sannsynligvis er den enkleste strengen i Groovy en med enkelt anførselstegn:

def eksempel = 'Hello world'

Under panseret er dette bare vanlig Java Strenger, og de kommer godt med når vi trenger å ha anførselstegn inne i strengen vår.

I stedet for:

def hardToRead = "Kacper elsker \" Ringenes herre \ ""

Vi kan enkelt sammenkoble en streng med en annen:

def easyToRead = 'Kacper elsker "Ringenes herre"'

Fordi vi kan bytte tilbudstyper som dette, reduserer det behovet for å unnslippe tilbud.

4. Triple Single-Quote String

En trippel enkelt sitatstreng er nyttig i sammenheng med å definere innhold med flere linjer.

La oss for eksempel si at vi har noen JSON å representere som en streng:

{"name": "John", "age": 20, "birthDate": null}

Vi trenger ikke å ty til sammenkobling og eksplisitte newline-tegn for å representere dette.

I stedet la oss bruke en trippel enkelt sitert streng:

def jsonContent = '' '{"name": "John", "age": 20, "birthDate": null}' ''

Groovy lagrer dette som en enkel Java Stringog legger til nødvendig sammenkobling og nye linjer for oss.

Det er likevel en utfordring å løse.

Vanligvis for kodelesbarhet, innrykker vi koden vår:

def triple = '' 'første linje andre linje' ''

Men triple single-quote strings bevarer hvitt mellomrom. Dette betyr at strengen ovenfor egentlig er:

(ny linje) første linje (ny linje) andre linje (ny linje)

ikke:

som kanskje vi hadde tenkt.

Følg med for å se hvordan vi blir kvitt dem.

4.1. Newline-karakter

La oss bekrefte det vår forrige streng starter med en ny linje karakter:

assertTrue (triple.startsWith ("\ n"))

Det er mulig å strippe den karakteren. For å forhindre dette, må vi sette en enkelt tilbakeslag \ som en første og siste karakter:

def triple = '' \ firstline secondline '' '

Nå har vi i det minste:

Ett problem nede, ett til å gå.

4.2. Strip koden innrykk

Deretter, la oss ta vare på fordypningen. Vi vil beholde formateringen, men fjerne unødvendige mellomromstegn.

Groovy String API kommer til unnsetning!

For å fjerne ledende mellomrom på hver linje i strengen vår, kan vi bruke en av Groovy-standardmetodene, String # stripIndent ():

def triple = '' '\ firstline secondline' ''. stripIndent () assertEquals ("firstline \ nsecondline", triple)

Vær oppmerksom på at ved å flytte flåttene opp en linje, Vi har også fjernet en etterfølgende karakter.

4.3. Relativ innrykk

Vi burde huske det stripIndent kalles ikke stripWhitespace.

stripIndent bestemmer innrykkingsmengden fra den forkortede linjen som ikke er mellomrom i strengen.

Så la oss endre fordypningen ganske mye for vår trippel variabel:

klasse TripleSingleQuotedString {@Test ugyldig 'trippel singel sitert med flerlinjestreng med siste linje med bare mellomrom' () {def trippel = '' 'første linje andre linje \' '' .stripIndent () // ... bruk trippel}}

Printing trippel vil vise oss:

første linje andre linje

Siden første linje er den minst innrykkede linjen som ikke er mellomrom, blir den null innrykket med andre linje fremdeles innrykket i forhold til det.

Vær også oppmerksom på at vi denne gangen fjerner det etterfølgende hvite området med en skråstrek, som vi så tidligere.

4.4. Strip med stripMargin ()

For enda mer kontroll kan vi fortelle Groovy rett hvor vi skal starte linjen ved å bruke a | og stripMargin:

def trippel = '' \ | første linje | andre linje ''. stripMargin ()

Som vil vise:

første linje andre linje

Røret angir hvor den linjen i strengen virkelig starter.

Vi kan også passere en Karakter eller CharSequence som et argument til stripMargin med vår egendefinerte skilletegn.

Flott, vi ble kvitt alt unødvendig mellomrom, og strengen vår inneholder bare det vi vil!

4.5. Unnslipper spesialtegn

Med alle oppsidene til den tredobbelte strengen med en sitat, er det en naturlig konsekvens av at vi trenger å unnslippe enkelt anførselstegn og tilbakeslag som er en del av strengen vår.

For å representere spesialtegn, må vi også unnslippe dem med en tilbakeslag. De vanligste spesialtegnene er en ny linje (\ n) og tabulering (\ t).

For eksempel:

def specialCharacters = '' hei \ 'John \'. Dette er tilbakeslag - \ \ nAndre linje starter her '' '

vil resultere i:

hei 'John'. Dette er tilbakeslag - \ Andre linje starter her

Det er noen vi må huske, nemlig:

• \ t - tabulering
• \ n - ny linje
• \ b - baksiden
• \ r - vognretur
• \\ - tilbakeslag
• \ f - formfeed
• \' - enkelt tilbud

5. Dobbelt sitert streng

Mens dobbel siterte strenger også bare er Java Strenger, deres spesielle kraft er interpolasjon. Når en dobbel sitert streng inneholder interpolasjonstegn, slår Groovy ut Java String for en G-streng.

5.1.G-streng og lat evaluering

Vi kan interpolere en dobbel sitert streng ved å omgir uttrykk med ${} eller med $ for prikkete uttrykk.

Evalueringen er lat, skjønt - det blir ikke konvertert til en String til den sendes til en metode som krever en String:

def string = "example" def stringWithExpression = "eksempel $ {2}" assertTrue (string instance of String) assertTrue (stringWithExpression instance of GString) assertTrue (stringWithExpression.toString () instance of String)

5.2. Plassholder med henvisning til en variabel

Det første vi sannsynligvis vil gjøre med interpolasjon er å sende den en variabel referanse:

def name = "John" def helloName = "Hello $ name!" assertEquals ("Hei John!", helloName.toString ())

5.2. Plassholder med uttrykk

Men vi kan også gi det uttrykk:

def result = "result is $ {2 * 2}" assertEquals ("result is 4", result.toString ())

Vi kan til og med sette uttalelser til plassholdere, men det regnes som dårlig praksis.

5.3. Plassholdere med prikkoperatøren

Vi kan til og med gå objekthierarkier i strengene våre:

def person = [name: 'John'] def myNameIs = "Jeg er $ person.name, og du?" assertEquals ("Jeg er John, og du?", myNameIs.toString ())

Hos getters kan Groovy vanligvis utlede eiendomsnavnet.

Men hvis vi kaller en metode direkte, må vi bruke ${}på grunn av parentesene:

def name = 'John' def result = "Store bokstaver: $ {name.toUpperCase ()}". toString () assertEquals ("Store bokstaver: JOHN", resultat)

5.4. hashCode i G-streng og String

Interpolerte strenger er absolutt god gave i forhold til vanlig java.util.Streng, men de skiller seg ut på en viktig måte.

Se, Java Strenger er uforanderlige, og så kaller hashCode på en gitt streng returnerer alltid den samme verdien.

Men, G-streng hashkoder kan variere siden String representasjon avhenger av de interpolerte verdiene.

Og faktisk, selv for samme resulterende streng, vil de ikke ha de samme hash-kodene:

def string = "2 + 2 er 4" def gstring = "2 + 2 er $ {4}" assertTrue (string.hashCode ()! = gstring.hashCode ())

Dermed skal vi aldri bruke G-streng som en nøkkel i en Kart!

6. Triple Double-Quote String

Så vi har sett to strenger med ett sitat, og vi har sett strenger med dobbelt sitat.

La oss kombinere kraften til begge deler for å få det beste fra begge verdener - flerlinjestrenginterpolasjon:

def name = "John" def multiLine = "" "Jeg heter $ name." Dette er sitat fra 'War and Peace' '"" ""

Legg også merke til det vi slapp å unnslippe enkelt- eller dobbelt-sitater!

7. Slashy String

La oss si at vi gjør noe med et regelmessig uttrykk, og vi unnslipper dermed tilbakeslag overalt:

def mønster = "\ d {1,3} \ s \ w + \ s \ w + \\ w +"

Det er helt klart et rot.

For å hjelpe deg med dette, Groovy støtter regex naturlig via slashy strenger:

def mønster = / \ d {3} \ s \ w + \ s \ w + \ w + / assertTrue ("3 Blind Mice \ Men" .matches (mønster))

Slashy strenger kan være både interpolert og flerlinjet:

def navn = 'John' def eksempel = / Kjære ([A-Z] +), Kjærlighet, $ navn /

Selvfølgelig må vi unnslippe fremover skråstreker:

def mønster = /.*foobar.*\/hello.*/ 

Og vi kan ikke representere en tom streng med Slashy Stringsiden kompilatoren forstår // som en kommentar:

// if ('' == //) {// println ("Jeg kan ikke kompilere") //}

8. Dollar-Slashy String

Slashy strenger er flott, selv om det er en bummer å måtte unnslippe den fremover skråstreken. For å unngå ytterligere rømming av en skråstrek fremover, kan vi bruke en dollar-slashy streng.

La oss anta at vi har et regex-mønster: [0-3]+/[0-3]+. Det er en god kandidat for dollar-slashy streng fordi vi i en slashy string må skrive: [0-3]+//[0-3]+.

Dollar-slashy strengene er flerlinjede G-strengs som åpnes med $ / og lukkes med / $. For å unnslippe en dollar eller en skråstrek, kan vi gå foran dollartegnet ($), men det er ikke nødvendig.

Vi trenger ikke unnslippe $ inn G-streng plassholder.

For eksempel:

def name = "John" def dollarSlashy = $ / Hallo $ name !, Jeg kan vise deg et $ -tegn eller et rømt dollartegn: $$ Begge skråstrekene fungerer: \ eller /, men vi kan fortsatt unnslippe det: $ / Vi har for å unnslippe åpnings- og lukkeavgrensere: - $$$ / - $ / $$ / $ 

ville sende:

Hei John !, Jeg kan vise deg et $ -tegn eller et rømt dollartegn: $ Begge skråstrekene fungerer: \ eller /, men vi kan fortsatt unnslippe det: / Vi må unnslippe åpnings- og lukkeavgrenseren: - $ / - / $

9. Karakter

De som er kjent med Java har allerede lurt på hva Groovy gjorde med tegn siden den bruker enkelt anførselstegn for strenger.

Faktisk, Groovy har ikke en eksplisitt karakter bokstavelig.

Det er tre måter å lage en Groovy streng en faktisk karakter:

• eksplisitt bruk av 'char' nøkkelord når man erklærer en variabel
• bruker ‘som’ operatør
• ved å kaste til 'røye'

La oss ta en titt på dem alle:

char a = 'A' char b = 'B' som char char c = (char) 'C' assertTrue (a instanceof Character) assertTrue (b instance of Character) assertTrue (c instance of Character)

Den første måten er veldig praktisk når vi vil beholde tegnet som en variabel. De to andre metodene er mer interessante når vi vil overføre et tegn som et argument til en funksjon.

10. Sammendrag

Det var tydeligvis mye, så la oss raskt oppsummere noen viktige punkter:

• strenger opprettet med et enkelt sitat (‘) støtter ikke interpolering
• slashy og tredoblet dobbelt-sitat strenger kan være multi-line
• flerstrengede strenger inneholder mellomromstegn på grunn av kodeinnrykk
• tilbakeslag (\) brukes til å unnslippe spesialtegn i alle typer, unntatt dollar-skråstrekk, der vi må bruke dollar ($) for å unnslippe

11. Konklusjon

I denne artikkelen diskuterte vi mange måter å lage en streng i Groovy og dens støtte for multilinjer, interpolering og regex.

Alle disse utdragene er tilgjengelige på Github.

Og for mer informasjon om funksjonene i selve Groovy-språket, få en god start med introduksjonen til Groovy.