18 czerwca 2009

Rozdział 6. o napisach w Groovy z "Programming Groovy"

Rozdział 6. "Working with Strings" dotyczy obsługi literałów i ciągów znakowych (napisów). Tworzymy literał znakowy w Groovy za pomocą pojedynczych cudzysłowów, np. 'cześć', a napisy z podwójnymi, np. "cześć". W przeciwieństwie do Javy, w Groovy 'a' i "a" są tymi samymi ciągami znaków typu String.
 groovy:000> a1 = 'a'
===> a
groovy:000> a2 = "a"
===> a
groovy:000> a1.class.name
===> java.lang.String
groovy:000> a2.class.name
===> java.lang.String
Jeśli chcielibyśmy stworzyć egzemplarz dla pojedynczego znaku (w Javie jako char lub java.lang.Character) wystarczy skorzystać z konstrukcji as char.
 groovy:000> a1 = 'a'
===> a
groovy:000> a1.class.name
===> java.lang.String
groovy:000> a3 = a1 as char
===> a
groovy:000> a3.class.name
===> java.lang.Character
Przypominam, że nie istnieją typy proste w Groovy, a ich użycie to w rzeczywistości utworzenie egzemplarza typu opakowującego, np. dla char będzie to java.lang.Character.

W ramach pojedynczych cudzysłowów możemy umieścić podwójne.
 groovy:000> a4 = '"a"'
===> "a"
groovy:000> a4.class.name
===> java.lang.String
Różnica między literałem a napisem jest w rozwiązywaniu wyrażeń ${}.
 groovy:000> wartosc = 5
===> 5
groovy:000> tekstJakoLiteral = 'Podano wartosc: ${wartosc}'
===> Podano wartosc: ${wartosc}
groovy:000> tekstJakoNapis = "Podano wartosc: ${wartosc}"
===> Podano wartosc: 5
Napisy są niezmienne (niemodyfikowalne, ang. immutable), więc zmiana ich wartości jest niemożliwa (chyba, że korzystają z domknięć zczytujących dane ze środowiska, ale sam napis jest niezmienny). Pamiętam, że rozgłaszałem coś zupełnie odwrotnego na ostatniej mojej prezentacji Groovy i Grails we Wrocławiu za co przepraszam. Tutaj nic się nie zmienia w stosunku do Javy.

Odczyt z literału bądź napisu jest poprzez symbol tablicowy [].
 groovy:000> napis = "Ala ma kota"
===> Ala ma kota
groovy:000> napis[0]
===> A
groovy:000> napis[0..3]
===> Ala
Specjalne znaki w napisach, np. $ (dolar) możemy pozbawić ich specjalności przez poprzedzenie ich ukośnikiem lewym '\' (ang. backslash), np. \$, albo przez skorzystanie z kolejnej konstrukcji do tworzenia specjalnych napisów przez użycie ukośnika prawego '/' (ang. slash).
 groovy:000> dolary = 500
===> 500
groovy:000>
groovy:000> napis = "Za 1 PLN placimy ${dolary}\$"
===> Za 1 PLN placimy 500$
groovy:000> napisUkosnikPrawy = /Za 1 PLN placimy ${dolary}$/
===> Za 1 PLN placimy 500$
groovy:000> dolary = 200
===> 200
groovy:000> napis
===> Za 1 PLN placimy 500$
groovy:000> napisUkosnikPrawy
===> Za 1 PLN placimy 500$
groovy:000> napisUkosnikPrawy = /Za 1 PLN placimy ${-> dolary}$/
===> Za 1 PLN placimy 200$
groovy:000> dolary = 10
===> 10
groovy:000> napisUkosnikPrawy
===> Za 1 PLN placimy 10$
Jak widać w przykładzie wyżej, Groovy rozwiązuje wartości zmiennych w napisach natychmiast podczas ich tworzenia (gorliwie), a opóźniony (leniwy) odczyt jest możliwy przez zastosowanie...domknięć (bezparametrowych).

Typem dla napisów z wyrażeniami ${} w Groovy jest GString (ang. Groovy string). Groovy inteligentnie przypisuje typ do naszych potrzeb.
 groovy:000> (/napis/).class
===> class java.lang.String
groovy:000> zmienna = 5
===> 5
groovy:000> (/napis ze zmienna ${zmienna}/).class
===> class org.codehaus.groovy.runtime.GStringImpl
groovy:000> "kolejny napis".class
===> class java.lang.String
groovy:000> "kolejny napis, ale juz ze zmienna ${zmienna}".class
===> class org.codehaus.groovy.runtime.GStringImpl
Połączenie GString i domknięć pokazuje jak Groovy traktuje domknięcia. Domknięcie to po prostu blok wykonywalny, który również może być przypisany do zmiennej, a użyty wprost będzie przypisany do zmiennej anonimowej.
 groovy:000> wartosc = 4
===> 4
groovy:000> napis = "Wypiszemy napis wykonujac domkniecie ${-> wartosc}"
===> Wypiszemy napis wykonujac domkniecie 4
groovy:000> napis = "Wypiszemy napis wykonujac domkniecie $wartosc"
===> Wypiszemy napis wykonujac domkniecie 4
// definiuję domknięcie
groovy:000> domkn = {-> wartosc}
===> groovysh_evaluate$_run_closure1@f268de
// i buduję napis ze zmienną, która jest domknięciem
groovy:000> napis = "Wypiszemy napis wykonujac domkniecie $domkn"
===> Wypiszemy napis wykonujac domkniecie 4
W Groovy napisy składające się z wielu linii budujemy z potrójnym podwójnym cudzysłowem i potrójnym pojedynczym cudzysłowem. Pięknie napisane, co? Innymi słowy, trzy razy piszemy pojedynczy cudzysłów, jeśli nie korzystamy z wyrażeń, a z nimi budujemy napis opakowany trzema podwójnymi.
 groovy:000> napisBezZmiennychNaKilkaLinii = '''Zaczynam pisac,
groovy:001> Linia 2
groovy:002> Linia 3 i kilka innych dodatkow, np. wyrazenie: $wartosc'''
===> Zaczynam pisac,
Linia 2
Linia 3 i kilka innych dodatkow, np. wyrazenie: $wartosc
groovy:000> napisZeZmiennymiNaKilkaLinii = """Linia 1
groovy:001> Linia 2
groovy:002> Linia 3 i zmienna $wartosc"""
===> Linia 1
Linia 2
Linia 3 i zmienna 4
Przydatne chociażby do tworzenia plików XML, albo, jak to ujął autor, "Groovy even makes it easy to spam! (Hey, I'm just kidding.)" (str. 109). Żartowniś! :)

W Groovy mamy przeciążanie operatorów, więc odejmowanie w napisach to wycinanie napisu. Dodano metodę minus() do typu String i możemy ciąć.
 groovy:000> napis = "Ala ma kota"
===> Ala ma kota
groovy:000> napis -= "ma"
===> Ala kota
Możemy również iterować po alfabecie, co w połączeniu z napisami daje niesamowity efekt iterowania po napisach.
 groovy:000> for (str in 'ala'..'alg') {
groovy:001> print "$str "
groovy:002> }
ala alb alc ald ale alf alg ===> null
Groovy rozszerza klasę String o udostępnienie metod do pracy z wyrażeniami regularnymi. W ten sposób poza replaceFirst() oraz replaceAll() mamy ~ (tylda) (odpowiada funkcji negate()), który tworzy egzemplarz wzorca, co w połączeniu z napisami tworzonymi przez ukośniki przypomina Perla.
 groovy:000> wzorzec = ~/\w*/
===> \w*
groovy:000> wzorzec.class.name
===> java.util.regex.Pattern
groovy:000> "Ala ma kota" =~ wzorzec
===> java.util.regex.Matcher[pattern=\w* region=0,11 lastmatch=]
groovy:000> matcher = "Ala ma kota" =~ wzorzec
===> java.util.regex.Matcher[pattern=\w* region=0,11 lastmatch=]
groovy:000> matcher.size()
===> 6
groovy:000> matcher[0]
===> Ala
groovy:000> matcher[1]
===>
groovy:000> for (wyraz in matcher) {
groovy:001> println "$wyraz"
groovy:002> }
Ala

ma

kota

===> null
Nawet, jeśli nie zaczniemy pisać rozwiązań przemysłowych w Groovy, to do skryptów jest bezkonkurencyjny. Zamiast Perla możemy wykorzystać JVM z Groovy - w chwilach słabości zawsze możemy zejść na poziom Javy.

Warto również przyjrzeć się różnicy między ==~ a =~. Pierwszy z nich sprawdza pełne dopasowanie, podczas gdy drugi jedynie częściowe.
 groovy:000> matcher = "Ala ma kota" ==~ /ma/
===> false
groovy:000> matcher = "Ala ma kota" =~ /ma/
===> java.util.regex.Matcher[pattern=ma region=0,11 lastmatch=]
groovy:000> matcher = "Ala ma kota" ==~ /Ala \w* kota/
===> true
Niestety nie udało mi się napisać wyrażenia regularnego w stylu /\w{6}/ i nie wiem, dlaczego przykład poniżej zwraca false.
 groovy:000> matcher = "Ala ma kota" ==~ /\w{6}/
===> false
Ma ktoś pomysł? Chętnie poznam rozwiązanie (i później będę się nim chwalił jak swoim :)). Na koniec przykład z książki (str. 113):
 groovy:000> str = 'Groovy is groovy, really groovy'
===> Groovy is groovy, really groovy
groovy:000> (str =~ /groovy/).replaceAll('hip')
===> Groovy is hip, really hip
Jestem zauroczony!

p.s. W komentarzu do wczorajszego wpisu Dokończenie rozdziału 5. o domknięciach z "Programming Groovy" pedro podniósł temat sprawdzenia, czy domknięcie jest faktycznie domknięciem. Odpowiedź w postaci przykładu.
 groovy:000> def funkcja(domkniecie) {
groovy:001> if (domkniecie && domkniecie instanceof Closure) { return domkniecie() }
groovy:002> println "Parametr wejsciowy typu: ${domkniecie.class.name}"
groovy:003> }
===> true
groovy:000> funkcja { "Jestem domknieciem!" }
===> Jestem domknieciem!
groovy:000> funkcja "Jestem jedynie napisem"
Parametr wejsciowy typu: java.lang.String
===> null
Dodałem sprawdzenie z wykorzystaniem instanceof.