A vonósok típusai a Groovy-ban

1. Áttekintés

Ebben az oktatóanyagban közelebbről megvizsgáljuk a Groovy többféle karakterláncát, beleértve az egyszeres, kétszeres, háromszoros és perjeles karakterláncokat is.

Megvizsgáljuk a Groovy speciális karakterek, többsoros, regex, menekülő és változó interpoláció karakterlánc-támogatását is.

2. Fokozás java.lang.String

Valószínűleg jó azzal kezdeni, hogy kijelentem, hogy mivel a Groovy Java-alapú, az összes Java-val rendelkezik Húr olyan képességek, mint az összefűzés, a String API és a String állandó készlet belső előnyei emiatt.

Először nézzük meg, hogyan bővíti Groovy ezeket az alapokat.

2.1. Vonós összefűzés

A húrok összefűzése csak két húr kombinációja:

def first = 'first' def second = "second" def concatenation = első + második assertEquals ('firstsecond', összefűzés)

Ahol erre épül a Groovy, számos más karakterlánccal rendelkezik, amelyeket pillanatok alatt megnézünk. Ne feledje, hogy az egyes típusokat felcserélhetjük.

2.2. Húrinterpoláció

Most a Java néhány nagyon egyszerű sablont kínál printf, de Groovy elmélyül, felajánlja karakterlánc interpoláció, a karakterláncok változókkal történő sablonozásának folyamata:

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

Míg a Groovy támogatja az összes karaktersorozat összefűzését, csak bizonyos típusok esetén nyújt interpolációt.

2.3. G húr

De ebben a példában elrejtve van egy kis ránc - miért hívunk toString ()?

Tulajdonképpen, eredmény nem típusú Húr, még akkor is, ha úgy néz ki.

Mert a Húr osztály az végső, Groovy karakterlánc-osztálya, amely támogatja az interpolációt, G húr, nem osztja alá. Más szóval, hogy Groovy biztosítsa ezt a fejlesztést, saját húrosztálya van, G húr, amely nem terjedhet ki Húr.

Egyszerűen fogalmazva, ha megtettük:

assertEquals ("Hello Kacper!", eredmény)

ez hivatkozik assertEquals (objektum, objektum), és megkapjuk:

java.lang.AssertionError: várható: java.lang.String, de a következő volt: org.codehaus.groovy.runtime.GStringImpl Várható: java.lang.String Actual: org.codehaus.groovy.runtime.GStringImpl

3. Egyidézett karakterlánc

Valószínűleg a Groovy legegyszerűbb karakterlánca egyetlen idézőjelben:

def example = 'Helló világ'

A motorháztető alatt ezek csak egyszerű Java Húrok, és jól jönnek amikor idézőjelek kellenek a húrunk belsejében.

Ahelyett:

def hardToRead = "Kacper szereti a" Gyűrűk urát "" "

Könnyen összefűzhetjük az egyik karakterláncot a másikkal:

def easyToRead = 'Kacper szereti a "Gyűrűk urát"'

Mivel cserélhetünk ilyen idézettípusokat, ez csökkenti az árajánlatok elkerülésének szükségességét.

4. Háromszoros egyetlen árajánlatú karakterlánc

A többsoros tartalmak definiálásakor egy hármas egyidős sztring hasznos.

Tegyük fel például, hogy van néhány JSON karakterláncként ábrázolni:

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

Ennek ábrázolásához nem kell összefűzéshez és kifejezetten új vonalakból álló karakterekhez folyamodnunk.

Ehelyett használjunk háromszoros idézőjelű karakterláncot:

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

Groovy ezt egyszerű Java-ként tárolja Húrés hozzáadja a számunkra szükséges összefűzést és új vonalakat.

Egy kihívás azonban még megoldandó.

Általában a kód olvashatósága érdekében behúzzuk a kódunkat:

def triple = '' 'első vonalas másodvonal' ''

De a háromszoros idézőjeles karakterláncok megőrzik a szóközöket. Ez azt jelenti, hogy a fenti karakterlánc valóban:

(új sor) első sor (új sor) második sor (új sor)

nem:

1 2 első sor (új sor)másodsor (új sor)

mint talán szándékoztuk.

Maradjon velünk, hogy lássa, hogyan szabadulunk meg tőlük.

4.1. Newline karakter

Erősítsük meg ezt előző sztringünk újsoros karakterrel kezdődik:

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

Lehetséges levetkőzni ezt a karaktert. Ennek megakadályozása érdekében egyetlen visszavágót kell tennünk \ első és utolsó karakterként:

def triple = '' '\ firstline secondline' ''

Most legalább van:

1 2 első sor (új sor)másodsor (új sor)

Egy probléma lefelé, még egyet kell megoldani.

4.2. Csíkolja le a kód behúzását

Ezután vigyázzunk a behúzásra. Meg akarjuk tartani a formázásunkat, de el kell távolítanunk a felesleges szóközöket.

A Groovy String API segít!

A karakterláncunk minden sorában levő szóközök eltávolításához használhatjuk a Groovy alapértelmezett metódusainak egyikét, Karakterlánc # stripIndent ():

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

Felhívjuk figyelmét, hogy a kullancsok felfelé mozgatásával mi is eltávolítottunk egy új vonalas karaktert.

4.3. Relatív behúzás

Erre emlékeznünk kellene stripIndent nem hívják stripWhitespace.

stripIndent meghatározza a behúzás mértékét a lánc rövidített, nem fehér szóközű sorából.

Tehát változtassuk meg kissé a behúzást a sajátunkkal hármas változó:

class TripleSingleQuotedString {@Test void 'triple single idézett többsoros karakterlánccal, az utolsó sor csak szóközökkel' () {def triple = '' '\ firstline secondline \' '' .stripIndent () // ... triple} használata

Nyomtatás hármas megmutatja nekünk:

első sor második sor

Mivel első sor a legkevésbé behúzott nem fehér szóköz, ezzel nullával behúzva lesz második sor még mindig behúzva ahhoz képest.

Ne feledje azt is, hogy ezúttal egy perjelrel távolítjuk el a záró szóközt, ahogyan azt korábban láttuk.

4.4. Csík stripMargin ()

A még nagyobb irányítás érdekében meg tudjuk mondani Groovynak, hogy hol kezdje a vonalat a | használatával és szalagMargin:

def triple = "" "\ | firstline | secondline '' '. stripMargin ()

Amely a következőket jelenítené meg:

első sor második sor

A cső állítja, hogy a húr melyik vonala valóban kezdődik.

Továbbá átmehetünk egy karakter vagy CharSequence érvként arra szalagMargin egyedi határoló karakterünkkel.

Remek, megszabadultunk minden felesleges szóköztől, és a húrunk csak azt tartalmazza, amit szeretnénk!

4.5. Menekülés a különleges karakterek közül

A hármas egy-idézetes karakterlánc minden felszínével együtt természetes következménye van annak, hogy el kell kerülnünk a karakterláncunk részét képező egyetlen idézetet és visszavágást.

A speciális karakterek ábrázolásához visszafelé is el kell kerülnünk őket. A leggyakoribb speciális karakterek egy újsor (\ n) és táblázatok (\ t).

Például:

def specialCharacters = "" szia "John". Ez a visszavonás - \ \ nA második sor itt kezdődik ""

eredményez:

Szia John'. Ez a visszavágás - \ A második sor itt kezdődik

Van néhány, amire emlékeznünk kell, nevezetesen:

  • \ t - táblázatok
  • \ n - új sor
  • \ b - visszalépés
  • \ r - kocsi vissza
  • \\ - visszavágás
  • \ f - formaadagolás
  • \' - egyetlen idézet

5. Dupla idézett karakterlánc

Míg a dupla idézett karakterláncok is csak Java Húrok, különleges hatalmuk az interpoláció. Ha egy dupla idézőjelű karakterlánc interpolációs karaktereket tartalmaz, Groovy kikapcsolja a Java-t Húr a G húr.

5.1.G húr és Lusta értékelés

Interpolálhatunk egy dupla idézett karakterláncot úgy, hogy a kifejezéseket körülvesszük ${} vagy azzal $ pontozott kifejezésekhez.

Az értékelése lusta, bár - nem alakul át a-ra Húr amíg át nem adják egy olyan módszerhez, amely a Húr:

def string = "példa" def stringWithExpression = "példa $ {2}" assertTrue (string String példánya String) assertTrue (stringWithExpression példája GString) assertTrue (stringWithExpression.toString () String példánya)

5.2. Helyőrző egy változóra hivatkozással

Az első dolog, amit valószínűleg meg akarunk csinálni az interpolációval, egy változó hivatkozás elküldése:

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

5.2. Helyőrző egy kifejezéssel

De kifejezéseket is adhatunk neki:

def eredmény = "az eredmény $ {2 * 2}" assertEquals ("az eredmény 4", result.toString ())

Akár állításokat is elhelyezhetünk helyőrzőkben, de ez rossz gyakorlatnak számít.

5.3. Helyőrzők a Dot Operatorban

Akár az objektum-hierarchiákat is bejárhatjuk a húrjainkba:

def person = [név: 'John'] def myNameIs = "$ person.name vagyok, és te?" assertEquals ("John vagyok, és te?", myNameIs.toString ())

Getterekkel Groovy általában következtetni tud az ingatlan nevére.

De ha egy módszert közvetlenül meghívunk, akkor használnunk kell ${}a zárójelek miatt:

def name = 'John' def result = "Nagybetű neve: $ {name.toUpperCase ()}". toString () assertEquals ("Nagybetű neve: JOHN", eredmény)

5.4. hash kód ban ben G húr és Húr

Az interpolált húrok minden bizonnyal istenadatok a sima kifejezéshez képest java.util.String, de fontos szempontból különböznek egymástól.

Lásd: Java Húrok megváltoztathatatlanok, és így hívják hash kód egy adott karaktersorozaton mindig ugyanazt az értéket adja vissza.

De, G húr a hashcodes változhat mivel a Húr ábrázolás az interpolált értékektől függ.

És valójában még ugyanazon eredő karakterlánc esetében sem lesznek azonos hash-kódok:

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

Így soha nem szabad használni G húr mint kulcs a Térkép!

6. Hármas dupla árajánlatú karakterlánc

Tehát láttunk hármas, egy idézetes karakterláncokat, és láttunk dupla idézett karakterláncokat.

Egyesítsük mindkettő erejét, hogy a lehető legjobban kihozzuk mindkét világot - többsoros karakterlánc-interpoláció:

def name = "John" def multiLine = "" "$ name vagyok." Ez a "Háború és béke" idézet "" ""

Ezt is vegye észre nem kellett megúsznunk az egyetlen vagy a dupla idézőjeleket!

7. Slashy húr

Tegyük fel, hogy szabályos kifejezéssel csinálunk valamit, és így mindenhol elkerüljük a visszavágásokat:

def minta = "\ d {1,3} \ s \ w + \ s \ w + \\ w +"

Egyértelműen rendetlenség.

Hogy segítsen ebben, Groovy pergős húrokon keresztül natív módon támogatja a regexet:

def minta = / \ d {3} \ s \ w + \ s \ w + \ w + / assertTrue ("3 vak egér \ férfi" .egyezik (minta))

Perjeles húrok lehet interpolált és többsoros is:

def név = 'János' def példa = / Kedves ([A-Z] +), szerelem, $ név /

Természetesen el kell menekülnünk a perjelektől:

def minta = /.*foobar.*\/szia.*/ 

És nem tudunk egy üres karakterláncot képviselni Slashy húrmivel a fordító megérti // megjegyzésként:

// if ('' == //) {// println ("Nem tudom lefordítani") //}

8. Dollár-pergő húr

A pergő húrok remekek, bár nagyszerű, ha el kell menekülni az előcsúsztatás elől. Annak elkerülése érdekében, hogy az előremenő perjel további szökését elkerüljük, használhatunk egy dollár-perjel karakterláncot.

Tegyük fel, hogy van egy regex mintánk: [0-3]+/[0-3]+. Ez jó jelölt a dollár-perjel karakterláncra, mert egy perjeles karakterláncban azt kellene írnunk: [0-3]+//[0-3]+.

Dollár-perjel a húrok többsorosak G húrs amelyek a $ / használatával nyílnak meg és a / $ értékkel záródnak. A dollár vagy az előrejelzés elkerülése érdekében megelőzhetjük a dollárjelet ($), de ez nem szükséges.

Nem kell megúsznunk a dollárt G húr helykitöltő.

Például:

def name = "John" def dollarSlashy = $ / Hello $ name !, megmutathatok egy $ jelet vagy egy megúszott dollárjelet: $$ Mindkét perjel működik: \ vagy /, de még mindig elkerülhetjük: $ / Van hogy elkerülje a nyitó és záró határolókat: - $$$ / - $ / $$ / $ 

kimenetet adna:

Helló, John !, tudok mutatni egy $ jelet vagy egy megúszott dollárjelet: $ Mindkét perjel működik: \ vagy /, de még mindig megúszhatjuk: / Meg kell menekülnünk a nyitó és záró határolótól: - $ / - / $

9. Karakter

Azok, akik ismerik a Java-t, már azon töprengtek, mit tett Groovy a karakterekkel, mivel egyetlen idézőjelet használ a karakterláncokhoz.

Tulajdonképpen, Groovy nem rendelkezik kifejezett karakter szó szerinti betűvel.

Vannak háromféleképpen hogy a Groovy karaktersorozat:

  • a „char” kulcsszó kifejezett használata egy változó deklarálásakor
  • az „as” operátor használatával
  • „char” -ba öntéssel

Vessünk egy pillantást mindegyikre:

char a = 'A' char b = 'B' mint char char c = (char) 'C' assertTrue (a Karakter példánya) assertTrue (Karakter b példánya) assertTrue (Karakter c példánya)

Az első módszer nagyon kényelmes, ha a karaktert változóként akarjuk megtartani. A másik két módszer akkor érdekes, ha egy karaktert argumentumként szeretnénk átadni egy függvénynek.

10. Összegzés

Nyilvánvalóan ez sok volt, ezért gyorsan foglaljuk össze néhány kulcsfontosságú kérdést:

  • az egyetlen idézettel (’) létrehozott karakterláncok nem támogatják az interpolációt
  • perjeles és hármas dupla idézőjelű karakterláncok többsorosak lehetnek
  • a többsoros karakterláncok szóközöket tartalmaznak a kód behúzása miatt
  • A backslash (\) a speciális karakterek elhagyására szolgál minden típusban, kivéve a dollár-perjel karakterláncot, ahol a dollárt ($) kell használnunk a meneküléshez

11. Következtetés

Ebben a cikkben számos módszert vitattunk meg egy karakterlánc létrehozására a Groovy-ban, valamint annak támogatását a többsoros, interpolációs és regexes támogatáshoz.

Ezek a kivonatok elérhetőek a Githubon.

És ha többet szeretne megtudni a Groovy nyelv sajátosságairól, kezdje jól a Groovy bevezetésünket.