Go: Strings

Go's string type is fundamentally different from the equivalent type in many other languages, where string types are all sequence of fixexd-with characters, whereas a Go string is a sequence of variable-width characters where each character is represented by one or more bytes, normally using UTF-8 encoding.

String literals are created using double quotes " or backticks `. Double quotes are used to create interpreted string literals, which support the escape sequences but may not span multiple lines. Backticks are used to create raw string literals — these strings may span multiple lines, they do not support any escape sequences and may contain any character except for a backtick.

text := "\"What's that?\", he said" // Interpreted string literal
text2 := `"What's that?", he said`  // Raw string literal
radicals := "√ \u221A \U0000221a"   // radicals == "√ √ √"
fmt.Printf("text = %s\ntext2 = %s\nradicals = %s", text, text2, radicals)

text = "What's that?", he said
text2 = "What's that?", he said
radicals = √ √ √

Go strings support the usual comparison operators: \(<\), \(<=\), \(==\), \(!=\), \(>=\), \(>\). The comparison operators compare strings byte by byte in memory. Three problems can arise when performing comparisons:

1. Some Unicode characters can be represented by two or more different byte sequences. For example, the character Å could be the Ångström symbol or simply an A with a ring above Å and can be represented by Unicode code point U+00C5 (Å) or by the two code points U+0041 and U+030A (A and COMBINING RING ABOVE). In terms of UTF-8 bytes symbols are represented with a different byte sequences and it can be different result for comparison and sorting strings with these symbols. It is always possible to write a custom normalization function that, for example, ensured that, say é was always represented by the bytes \([0xC3, 0xA9]\) rather than, say, \([0x65, 0xCC, 0x81]\) (i.e., an e and an combining character). Normalizing Unicode characters is explanet in the Unicode Normalization document.The Go standard library has an experimental normalization package (exp/norm).
2. The second is that there are cases where our users might reasonably expect different characters to be considered equal. Users might expect a search for \(5\) to match \(5\), \(_{5}\), \(^{5}\), and maybe even \(➄\). As with the first problem this can be solved by using some form of normalization.
3. Sorting of some characters is language-specific.

A single character can be represented by a single rune (or int32). Go strings represent sequences of zero or more characters. We can convert a single character into a one-character string using Go's standard conversion syntax:

æs := ""
for _, char := range []rune{'æ', 0xE6, 0346, 230, '\xE6', '\u00E6'} {
        fmt.Printf("[0x%X '%c']", char, char)
        æs += string(char)
}
fmt.Println()
fmt.Println(æs)

[0xE6 'æ'][0xE6 'æ'][0xE6 'æ'][0xE6 'æ'][0xE6 'æ'][0xE6 'æ']
ææææææ

An entire string can be converted to a slice of runes (i.e. code points) using the syntax chars := []rune (s) where s is of type string. The chars will have type []int32 since rune is a synonym for int32. The reverse conversion is using syntax s := string(chars) where chars is of type []rune or []int32; s will have type string. Both conversions are reasonably fast (\(O(n)\) where \(n\) is the number of bytes)

Since Go strings store their text as UTF-8 encoded bytes we must be careful to only ever slice on character boundaries. This is easy if we have 7-bit ASCII text since every byte represents one character, but for non-ASCII text the situation is more challenging since such characters may be represented by one or more bytes. Usually we don't need to slice strings at all but simply iterate over them character by character using a for … range loop, but in some situations we really do want to extract substrings using slicing. One way to be sure to use slice indexes that slice on character boundaries is to use functions from Go's strings packages, such as strings.Index() or strings.LastIndex(). If we really need to index individual characters, a couple of options are open to us. For strings that contain only 7-bit ASCII we can simply use the [] index operator which gives us very fast (\(O(1)\)) lookups. For non-ASCII strings we can convert the string to a []rune and use the [] index operator. This delivers very fast (\(O(1)\)) lookup performance, but at the expense of the one-off conversion which costs both CPU and memory (\(O(n)\)). For arbitrary strings (i.e., those that might contain non-ASCII characters), extracting characters by index is rarely the right apprroach. Much better is to use string slicing — which also has the convenience of returning a string rather than a byte.

line := "røde og gule sløjfer"
i := strings.Index(line, " ")    // Get the index of the first space
firstWord := line[:i]            // Slice up to the first space
j := strings.LastIndex(line, " ") // Get the index of the last space
lastWord := line[j+1:]           // Slice from after the last space
fmt.Println(firstWord, lastWord)

røde sløjfer

Although this example is fine for spaces and would also work for other 7-bit ASCII characters, it isn't suitable for working with arbitrary Unicode whitespace characters such as U+2028 (Line Separator 
) or U+2029 (Paragraph Separator 
).

line := "rå tørt\u2028vær"
i := strings.IndexFunc(line, unicode.IsSpace)
firstWord := line[:i]
j := strings.LastIndexFunc(line, unicode.IsSpace)
_, size := utf8.DecodeRuneInString(line[j:])
lastWord := line[j+size:]
fmt.Println(firstWord, lastWord)

rå vær

Go's standard library's fmt package provides print functions for writing data as strings to the console, to files and other values satisfying the io.Writer interface, and to other strings. The fmt package also provides various scan functions for reading data from the console, from the files, and from strings.

type polar struct{ radius, θ float64 }

p := polar{8.32, .49}
fmt.Print(-18.5, 17, "Elephant", -8+.7i, 0x3C7, '\u03C7', "a", "b", p)
fmt.Println()
fmt.Println(-18.5, 17, "Elephant", -8+.7i, 0x3C7, '\u03C7', "a", "b", p)