Operations on strings and string-based data are common tasks in a developer's life. This chapter covers how to handle these using the Go standard library. It is no surprise that with the standard library it is possible to do a great deal.

Finding the substring in a string is one of the most common tasks for developers. Most of the mainstream languages implement this in a standard library. Go is not an exception. This recipe describes the way Go implements this.

1. Open the console and create the folder chapter02/recipe01.
2. Navigate to the directory.
3. Create the contains.go file with the following content:

        package main

        import (
          "fmt"
          "strings"
        )

        const refString = "Mary had a little lamb"

        func main() {

          lookFor := "lamb"
          contain := strings.Contains(refString, lookFor)
          fmt.Printf("The \&quot...

Breaking the string into words could be tricky. First, decide what the word is, as well as what the separator is, and if there is any whitespace or any other characters. After these decisions have been made, you can choose the appropriate function from the strings package. This recipe will describe common cases.

1. Open the console and create the folder chapter02/recipe02.
2. Navigate to the directory.
3. Create the whitespace.go file with the following content:

        package main

        import (
          "fmt"
          "strings"
        )

        const refString = "Mary had a little lamb"
 
        func main() {

          words := strings.Fields(refString...

The recipe, Breaking the string into words, led us through the task of splitting the single string into substrings, according to defined rules. This recipe, on the other hand, describes how to concatenate the multiple strings into a single string with a given string as the separator.

A real use case could be the problem of dynamically building a SQL select statement condition.

1. Open the console and create the folder chapter02/recipe03.
2. Navigate to the directory.
3. Create the join.go file with the following content:

        package main

        import (
          "fmt"
          "strings"
        )

        const selectBase = "SELECT * FROM user WHERE...

Besides the built-in + operator, there are more ways to concatenate the string. This recipe will describe the more performant way of concatenating strings with the bytes package and the built-in copy function.

1. Open the console and create the folder chapter02/recipe04.
2. Navigate to the directory.
3. Create the concat_buffer.go file with the following content:

       package main

       import (
         "bytes"
         "fmt"
       )

       func main() {
         strings := []string{"This ", "is ", "even ",
                             "more ", "performant "}
          buffer := bytes.Buffer{}
          for _, val...

In certain cases, the output (usually data output) is done via tabbed text, which is formatted in well-arranged cells. This format could be achieved with the text/tabwriter package. The package provides the Writer filter, which transforms the text with the tab characters into properly formatted output text.

1. Open the console and create the folder chapter02/recipe05.
2. Navigate to the directory.
3. Create the tabwriter.go file with the following content:

        package main

        import (
          "fmt"
          "os"
          "text/tabwriter"
        )

        func main() {

          w := tabwriter.NewWriter(os.Stdout, 15, 0, 1, ' ',
           ...

Another very common task related to string processing is the replacement of the substring in a string. Go standard library provide the Replace function and Replacer type for the replacement of multiple strings at once.

1. Open the console and create the folder chapter02/recipe06.
2. Navigate to the directory.
3. Create the replace.go file with the following content:

        package main

        import (
         "fmt"
         "strings"
        )

        const refString = "Mary had a little lamb"
        const refStringTwo = "lamb lamb lamb lamb"

        func main() {
          out := strings.Replace(refString, "lamb", "wolf", -1)
   ...

There are always tasks such as validating the input, searching the document for any information, or even cleaning up a given string from unwanted escape characters. For these cases, regular expressions are usually used.

The Go standard library contains the regexp package, which covers the operations with regular expressions.

1. Open the console and create the folder chapter02/recipe07.
2. Navigate to the directory.
3. Create the regexp.go file with the following content:

        package main

        import (
          "fmt"
          "regexp"
        )

        const refString = `[{ \"email\": \"email@example.com\" \
             ...

A lesser-known fact is that all content in .go files is encoded in UTF-8. Believe it or not the Unicode is not, the only charset in the world. For example, the Windows-1250 encoding is widely spread across Windows users.

When working with non-Unicode strings, you need to transcode the content to Unicode. This recipe demonstrates how to decode and encode the non-Unicode strings.

1. Open the console and create the folder chapter02/recipe08.
2. Navigate to the directory.
3. Create the file win1250.txt with content Gdańsk. The file must be encoded in the windows-1250 charset. If you are not sure how to do that, just jump to step 6 and after you complete step 7, which...

There are a lot of practical tasks where the modification of case is the most common approach. Let's pick a few of these:

• Case-insensitive comparison
• Beginning the sentence with an automatic first capital
• Camel-case to snake-case conversion

For these purposes, the strings package offers functions ToLower, ToUpper, ToTitle, and Title.

1. Open the console and create the folder chapter02/recipe09.
2. Navigate to the directory.
3. Create the case.go file with the following content:

        package main

        import (
          "fmt"
          "strings"
          "unicode"
        )

        const email = "ExamPle@domain.com"
        const name = "isaac newton...

There are multiple table data formats. CSV (comma-separated values) is one of the most basic formats largely used for data transport and export. There is no standard that defines CSV, but the format itself is described in RFC 4180.

This recipe introduces how to parse CSV-formatted data comfortably.

1. Open the console and create the folder chapter02/recipe10.
2. Navigate to the directory.
3. Create a file named data.csv with the following content:

        "Name","Surname","Age"
        # this is comment in data
        "John","Mnemonic",20
        Maria,Tone,21

4. Create the data.go file with the following content:

        package main

    ...

The string input could contain too much whitespace, too little whitespace, or unsuitable whitespace chars. This recipe includes tips on how to manage these and format the string to your needs.

1. Open the console and create the folder chapter02/recipe11.
2. Navigate to the directory.
3. Create a file named whitespace.go with the following content:

        package main

        import (
          "fmt"
          "math"
          "regexp"
          "strconv"
          "strings"
        )

        func main() {

          stringToTrim := "\t\t\n Go \tis\t Awesome \t\t"
          trimResult := strings.TrimSpace(stringToTrim)
          fmt.Println...

The previous recipe depicts how to do string padding and whitespace trimming. This one will guide you through the indentation and unindentation of a text document. Similar principles from the previous recipes will be used.

1. Open the console and create the folder chapter02/recipe12.
2. Create the file main.go with the following content:

         package main

         import (
           "fmt"
           "strconv"
           "strings"
           "unicode"
         )

         func main() {

           text := "Hi! Go is awesome."
           text = Indent(text, 6)
           fmt.Println(text)

           text = Unindent(text, 3)
           fmt.Println...