Strings & GStrings

def zone = 'north'

def single   = 'It\'s a "greenhouse" in $zone'          // no interpolation
def tripleS  = '''first line
second line'''                                         // multi-line, no interpolation
def dq       = "Zone: ${zone}"                         // interpolation
def tripleD  = """Zone ${zone}
  has "quotes" freely"""                               // multi-line, interpolation
def slashy   = /C:\greenhouse\${zone}\d+/              // interpolation, backslash is literal
def dollarSl = $/Cost: $$5 and a slash // and \d in ${zone}/$

[single, tripleS, dq, tripleD, slashy, dollarSl].each { println it }
println '---'
println([single, tripleS, dq, tripleD, slashy, dollarSl]*.class*.simpleName)

It's a "greenhouse" in $zone
first line
second line
Zone: north
Zone north
  has "quotes" freely
C:\greenhouse\north\d+
Cost: $5 and a slash // and \d in north
---
[String, String, GStringImpl, GStringImpl, GStringImpl, GStringImpl]

println 'tab:\tX'
println 'unicode: \u00e9 \u20AC'
println 'backslash: \\ quote: \' dq: \"'
println "dollar: \$5"
println 'octal: \101'
def joined = 'one line, \
written on two'
println joined
println(/slash: \/ and backslash-d: \d/)
println($/dollar: $$ slash: $/ literal: \d/$)

tab:	X
unicode: é €
backslash: \ quote: ' dq: "
dollar: $5
octal: A
one line, written on two
slash: / and backslash-d: \d
dollar: $ slash: / literal: \d

char c1 = 'a'                    // a single-character string converted to char
def c2 = 'b' as char
def c3 = (char) 'c'
def s  = 'd'                     // still a String
println([c1, c2, c3, s]*.class*.simpleName)
println((c1 as int))             // 97
println((char) 100)              // d
println 'abc'[1]                 // indexing returns a String, not a char
println 'abc'.charAt(1).class.simpleName

[Character, Character, Character, String]
97
d
b
Character

def name = 'tomato'
def plant = [name: 'basil', zone: [id: 7]]

println "Plain: $name"
println "Expression: ${name.size() * 2}"
println "Dotted: $plant.name in zone $plant.zone.id"
println "Method call needs braces: ${name.toUpperCase()}"
try {
    println "Not a method call: $name.length"
} catch (MissingPropertyException e) {
    println e.message
}
println "Null renders as text: ${null}"
println "Collections: ${[1, 2]} and ${[a: 1]}"
println "A dollar sign: \$5, and a quote: $name's"
println "Nested: ${"inner ${name}"}"

Plain: tomato
Expression: 12
Dotted: basil in zone 7
Method call needs braces: TOMATO
No such property: length for class: java.lang.String
Null renders as text: null
Collections: [1, 2] and [a:1]
A dollar sign: $5, and a quote: tomato's
Nested: inner tomato

def n = 5
def gs = "n=${n}"

assert gs == 'n=5'                         // == compares text
assert 'n=5' == gs
assert !gs.equals('n=5')                   // equals() does not: a GString is not a String
assert !'n=5'.equals(gs)
assert gs.toString().equals('n=5')
assert gs.hashCode() != 'n=5'.hashCode()   // hashCodes differ
assert gs.class.name == 'org.codehaus.groovy.runtime.GStringImpl'

def lookup = ['n=5'] as Set
assert !lookup.contains(gs)                // hash-based lookups miss
assert lookup.contains(gs.toString())

def key = 'zone'
def m = [zone: 1]
println m.get("${key}")                    // null: a plain Map lookup with a GString misses
println m["${key}"]                        // 1: the subscript operator converts to String
println m."$key"                           // 1: dynamic property name
def m2 = [("${key}"): 2]                   // the key is stored as a GString
println m2.keySet()*.class*.simpleName
println m2['zone']                         // null: the stored key is a GString

null
1
1
[GStringImpl]
null

def a = 'x'
def b = 3
println a + b                              // String plus Integer
println a + " ${b}"                        // String plus GString
println(("${a}" + 'y').class.simpleName)   // GString plus String is a GString
println 'ab' * 3                           // repeat
println 'hello' - 'l'                      // removes the first occurrence
def sb = new StringBuilder('s')
sb << 'tr' << 1                            // << appends to a StringBuilder
println sb
println('a' << 'b' << 'c')                 // on a String it builds a StringBuffer

void takes(String s) { println "received ${s.class.simpleName}" }
takes("v=${b}")                            // the GString is converted at the call
takes('v')

x3
x 3
GStringImpl
ababab
helo
str1
abc
received String
received String

def report = '''\
    Zone A
      tomato 12
    Zone B'''
println report.stripIndent()        // removes the common leading indentation
println '--'
def withTrailingNewline = '''\
    Zone A
      tomato 12
'''
print withTrailingNewline.stripIndent()   // the empty last line counts: nothing is removed
println '--'
println '''\
    |Zone A
    |  basil 4
    |Zone B'''.stripMargin()         // removes everything up to and including '|'
println '--'
println '''\
    #Zone A
    #  mint 2'''.stripMargin('#')    // custom margin character
println '--'
println 'a\nb\r\nc'.readLines()
println '''first
second'''.lines().toList()
println 'continued \
line'

Zone A
  tomato 12
Zone B
--
    Zone A
      tomato 12
--
Zone A
  basil 4
Zone B
--
Zone A
  mint 2
--
[a, b, c]
[first, second]
continued line

def csv = 'tomato, basil;mint  chive'
println csv.tokenize(', ;')                          // splits on any of the characters
println csv.split(/[,; ]+/).toList()                 // splits on a regex, like Java
println 'a,b,,'.split(',').toList()                  // Java drops trailing empties
println 'a,b,,'.split(',', -1).toList()              // ... unless the limit is negative
println 'a,b,,'.tokenize(',')

println 'abc'.padLeft(6, '*') + '|' + 'abc'.padRight(6) + '|' + 'abc'.center(7, '-')
println 'hello'.tr('el', 'ip')
println 'hello world'.capitalize() + ' ' + 'Hello'.uncapitalize()
println '42'.toInteger() + 1
println '3.5'.toBigDecimal()
println(['42'.isNumber(), 'x42'.isNumber(), '42'.isInteger(), '4.2'.isDouble()])
'one\ntwo'.eachLine { line, n -> println "${n}: ${line}" }
println 'abcdef'.takeWhile { it != 'd' }
println 'abcdef'.dropWhile { it != 'd' }
println 'abcdef'.take(2) + '|' + 'abcdef'.drop(4) + '|' + 'abcdef'.takeRight(2) + '|' + 'abcdef'.dropRight(2)
println 'abcdef'[1..3] + ' ' + 'abcdef'[-2..-1] + ' ' + 'abcdef'[3..0] + ' ' + 'abcdef'[2..<4]
println 'hello'.reverse() + ' ' + 'hello'.count('l') + ' ' + 'hello world'.find(/w\w+/)
println 'a1b22'.findAll(/\d+/)
println 'snake_case_name'.split('_').collect { it.capitalize() }.join()
println 'abc'.next() + ' ' + 'abc'.previous()
println 'a b c'.collect { it.toUpperCase() }
println '%d items'.formatted(3) + ' ' + String.format('%05.1f', 3.14159)
println 'camelCaseName'.split(/(?=[A-Z])/).toList()
println(['x'.isEmpty(), ''.isEmpty(), ' '.isBlank(), '  pad '.trim()])
println(['abc'.compareTo('abd'), 'abc' <=> 'abd', 'abc' < 'abd'])

[tomato, basil, mint, chive]
[tomato, basil, mint, chive]
[a, b]
[a, b, , ]
[a, b]
***abc|abc   |--abc--
hippo
Hello world hello
43
3.5
[true, false, true, true]
0: one
1: two
abc
def
ab|ef|ef|abcd
bcd ef dcba cd
olleh 2 world
[1, 22]
SnakeCaseName
abd abb
[A,  , B,  , C]
3 items 003,1
[camel, Case, Name]
[false, true, true, pad]
[-1, -1, true]