Типи струн у Groovy

1. Огляд

У цьому навчальному посібнику ми детальніше розглянемо кілька типів рядків у Groovy, включаючи рядки з одинарними цитатами, подвійними цитатами, потрійними лапками та рябими рядами.

Ми також вивчимо підтримку рядків Groovy для спеціальних символів, багаторядкових, регулярних виразів, екрануючої та змінної інтерполяції.

2. Підвищення java.lang.String

Напевно, добре почати з того, що, оскільки Groovy заснований на Java, він має всі можливості Java String, такі як конкатенація, String API та невід'ємні переваги постійного пулу String через це.

Давайте спочатку подивимося, як Groovy розширює деякі з цих основ.

2.1. Конкатенація рядків

Об’єднання рядків - це лише комбінація двох рядків:

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

Де Groovy спирається на це, з кількома іншими типами рядків, на які ми подивимося через мить. Зверніть увагу, що ми можемо поєднати кожен тип взаємозамінно.

2.2. Інтерполяція рядка

Зараз Java пропонує кілька базових шаблонів через printf , але Groovy заглиблюється, пропонуючи інтерполяцію рядків, процес шаблонування рядків із змінними :

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

Хоча Groovy підтримує конкатенацію для всіх типів рядків, він забезпечує інтерполяцію лише для певних типів.

2.3. GString

Але в цьому прикладі приховано невелику зморшку - чому ми викликаємо toString () ?

Насправді результат не має типу String , навіть якщо він схожий.

Оскільки клас String є остаточним , клас рядків Groovy, який підтримує інтерполяцію, GString , не підкласує його. Іншими словами, для того, щоб Groovy забезпечив це вдосконалення, він має власний клас рядків, GString , який не може поширюватися від String.

Простіше кажучи, якщо ми це зробили:

assertEquals("Hello Kacper!", result)

це викликає assertEquals (Object, Object), і ми отримуємо:

java.lang.AssertionError: expected: java.lang.String but was: org.codehaus.groovy.runtime.GStringImpl Expected :java.lang.String Actual :org.codehaus.groovy.runtime.GStringImpl

3. Рядок з одинарними цитатами

Ймовірно, найпростіший рядок у Groovy - це одинарні лапки:

def example = 'Hello world'

Під капотом це просто звичайні старі Java- рядки , і вони стануть в нагоді, коли нам потрібно мати лапки всередині нашого рядка.

Замість:

def hardToRead = "Kacper loves \"Lord of the Rings\""

Ми можемо легко об'єднати один рядок з іншим:

def easyToRead = 'Kacper loves "Lord of the Rings"'

Оскільки ми можемо обмінюватися цитатами, як це, це зменшує необхідність уникати цитат.

4. Потрійний рядок з однією цитатою

Потрійний рядок з одинарними лапками корисний у контексті визначення багаторядкового вмісту.

Наприклад, скажімо, у нас є якийсь JSON, який буде представлений у вигляді рядка:

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

Нам не потрібно вдаватися до об’єднання та явних символів нового рядка, щоб це представляти.

Натомість використаємо потрійний рядок із одинарними лапками:

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

Groovy зберігає це як просту Java String і додає необхідну конкатенацію та нові рядки для нас.

Однак є ще одна проблема, яку потрібно подолати.

Зазвичай для читабельності коду ми робимо відступ нашого коду:

def triple = ''' firstline secondline '''

Але потрійні рядки з одинарними лапками зберігають пробіли . Це означає, що наведений вище рядок насправді:

(newline) firstline(newline) secondline(newline)

ні:

1 2 firstline(newline)secondline(newline)

як, можливо, ми задумали.

Stay tuned to see how we get rid of them.

4.1. Newline Character

Let's confirm that our previous string starts with a newline character:

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

It's possible to strip that character. To prevent this, we need to put a single backslash \ as a first and last character:

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

Now, we at least have:

1 2 firstline(newline)secondline(newline)

One problem down, one more to go.

4.2. Strip the Code Indentation

Next, let's take care of the indentation. We want to keep our formatting, but remove unnecessary whitespace characters.

The Groovy String API comes to the rescue!

To remove leading spaces on every line of our string, we can use one of the Groovy default methods, String#stripIndent():

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

Please note, that by moving the ticks up a line, we've also removed a trailing newline character.

4.3. Relative Indentation

We should remember that stripIndent is not called stripWhitespace.

stripIndent determines the amount of indentation from the shortened, non-whitespace line in the string.

So, let's change the indentation quite a bit for our triple variable:

class TripleSingleQuotedString { @Test void 'triple single quoted with multiline string with last line with only whitespaces'() { def triple = '''\ firstline secondline\ '''.stripIndent() // ... use triple } }

Printing triple would show us:

firstline secondline

Since firstline is the least-indented non-whitespace line, it becomes zero-indented with secondline still indented relative to it.

Note also that this time, we are removing the trailing whitespace with a slash, like we saw earlier.

4.4. Strip with stripMargin()

For even more control, we can tell Groovy right where to start the line by using a | and stripMargin:

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

Which would display:

firstline secondline

The pipe states where that line of the string really starts.

Also, we can pass a Character or CharSequence as an argument to stripMargin with our custom delimiter character.

Great, we got rid of all unnecessary whitespace, and our string contains only what we want!

4.5. Escaping Special Characters

With all the upsides of the triple single-quote string, there is a natural consequence of needing to escape single quotes and backslashes that are part of our string.

To represent special characters, we also need to escape them with a backslash. The most common special characters are a newline (\n) and tabulation (\t).

For example:

def specialCharacters = '''hello \'John\'. This is backslash - \\ \nSecond line starts here'''

will result in:

hello 'John'. This is backslash - \ Second line starts here

There are a few we need to remember, namely:

  • \t – tabulation
  • \n – newline
  • \b – backspace
  • \r – carriage return
  • \\ – backslash
  • \f – formfeed
  • \' – single quote

5. Double-Quoted String

While double-quoted strings are also just Java Strings, their special power is interpolation. When a double-quoted string contains interpolation characters, Groovy switches out the Java String for a GString.

5.1.GString and Lazy Evaluation

We can interpolate a double-quoted string by surrounding expressions with ${} or with $ for dotted expressions.

Its evaluation is lazy, though – it won't be converted to a String until it is passed to a method that requires a String:

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

5.2. Placeholder with Reference to a Variable

The first thing we probably want to do with interpolation is send it a variable reference:

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

5.2. Placeholder with an Expression

But, we can also give it expressions:

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

We can put even statements into placeholders, but it's considered as bad practice.

5.3. Placeholders with the Dot Operator

We can even walk object hierarchies in our strings:

def person = [name: 'John'] def myNameIs = "I'm $person.name, and you?" assertEquals("I'm John, and you?", myNameIs.toString())

With getters, Groovy can usually infer the property name.

But if we call a method directly, we'll need to use ${}because of the parentheses:

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

5.4. hashCode in GString and String

Interpolated strings are certainly godsends in comparison to plain java.util.String, but they differ in an important way.

See, Java Strings are immutable, and so calling hashCode on a given string always returns the same value.

But, GString hashcodes can vary since the String representation depends on the interpolated values.

And actually, even for the same resulting string, they won't have the same hash codes:

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

Thus, we should never use GString as a key in a Map!

6. Triple Double-Quote String

So, we've seen triple single-quote strings, and we've seen double-quoted strings.

Let's combine the power of both to get the best of both worlds – multi-line string interpolation:

def name = "John" def multiLine = """ I'm $name. "This is quotation from 'War and Peace'" """

Also, notice that we didn't have to escape single or double-quotes!

7. Slashy String

Now, let's say that we are doing something with a regular expression, and we are thus escaping backslashes all over the place:

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

It's clearly a mess.

To help with this, Groovy supports regex natively via slashy strings:

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

Slashy strings may be both interpolated and multi-line:

def name = 'John' def example = / Dear ([A-Z]+), Love, $name /

Of course, we have to escape forward slashes:

def pattern = /.*foobar.*\/hello.*/ 

And we can't represent an empty string with Slashy Stringsince the compiler understands // as a comment:

// if ('' == //) { // println("I can't compile") // }

8. Dollar-Slashy String

Slashy strings are great, though it's a bummer to have to escape the forward slash. To avoid additional escaping of a forward slash, we can use a dollar-slashy string.

Let's assume that we have a regex pattern: [0-3]+/[0-3]+. It's a good candidate for dollar-slashy string because in a slashy string, we would have to write: [0-3]+//[0-3]+.

Dollar-slashy strings are multiline GStrings that open with $/ and close with /$. To escape a dollar or forward slash, we can precede it with the dollar sign ($), but it's not necessary.

We don't need to escape $ in GString placeholder.

For example:

def name = "John" def dollarSlashy = $/ Hello $name!, I can show you a $ sign or an escaped dollar sign: $$ Both slashes work: \ or /, but we can still escape it: $/ We have to escape opening and closing delimiters: - $$$/ - $/$$ /$ 

would output:

Hello John!, I can show you a $ sign or an escaped dollar sign: $ Both slashes work: \ or /, but we can still escape it: / We have to escape opening and closing delimiter: - $/ - /$

9. Character

Those familiar with Java have already wondered what Groovy did with characters since it uses single quotes for strings.

Actually, Groovy doesn't have an explicit character literal.

There are three ways to make a Groovy string an actual character:

  • explicit use of ‘char' keyword when declaring a variable
  • using ‘as' operator
  • by casting to ‘char'

Let's take a look at them all:

char a = 'A' char b = 'B' as char char c = (char) 'C' assertTrue(a instanceof Character) assertTrue(b instanceof Character) assertTrue(c instanceof Character)

The first way is very convenient when we want to keep the character as a variable. The other two methods are more interesting when we want to pass a character as an argument to a function.

10. Summary

Очевидно, це було багато, тому давайте швидко узагальнимо деякі ключові моменти:

  • рядки, створені однією лапкою ('), не підтримують інтерполяцію
  • слеші та потрійні рядки з подвійними лапками можуть бути багаторядковими
  • багаторядкові рядки містять пробіли через відступ коду
  • зворотна коса риса (\) використовується для уникнення спеціальних символів у кожному типі, за винятком рядового рядка, де ми повинні використовувати долар ($) для втечі

11. Висновок

У цій статті ми обговорили багато способів створити рядок у Groovy та підтримку багаторядкових рядків, інтерполяції та регулярного виразу.

Усі ці фрагменти доступні на Github.

А для отримання додаткової інформації про особливості мови Groovy розпочніть з нашого вступу до Groovy.