In this recipe, we will look at how to create strings in a program.

How to do it...

• Use a string literal. There are two types of string literals in Go:
  • Use interpreted string literals, between the double quotations:

    x := "Hello world"

  • With interpreted string literals, you must escape certain characters:

    x:="This is how you can include a \" in your string literal"
    y:="You can also use a newline \n, tab \t"

  • You can include Unicode codepoints or hexadecimal bytes, escaped with '\':

    w:="\u65e5本\U00008a9e"
    x:="\xff"

You cannot have newlines or an unescaped double-quote in an interpreted string:

• Use raw string literals, using backticks. A raw string literal can include any characters (including newlines) except a backtick. There is no way to escape backticks in a raw literal.

  x:=`This is a
  multiline raw string literal.
  Backslash will print as backslash \`

If you need to include...

The Go standard library offers multiple ways to substitute values in a text template. Here, we will discuss the text formatting utilities in the fmt package. They offer a simple and convenient way to substitute values in a text template.

How to do it...

• Use the fmt.Print family of functions to format values
• fmt.Print will print a value using its default formatting
• A string value will be printed as is
• A numeric value will be first converted to a string as an integer, a decimal number, or by using scientific notation for large exponents
• A Boolean value will be printed as true or false
• Structured values will be printed as a list of fields

If a Print function ends with ln (such as fmt.Println), a new line will be output after the string.

If a Print function ends with f, the function will accept a format argument, which will be used as the template into which it will substitute values.

fmt.Sprintf will format a string and return...

The Go standard library offers multiple ways to build strings from components. The best way depends on what type of strings you are dealing with, and how long they are. This section shows several ways that strings can be built.

How to do it...

• To combine a few fixed numbers of strings, or to add runes to another string, use the + or += operators or string.Builder
• To build a string algorithmically, use strings.Builder
• To combine a slice of strings, use strings.Join
• To combine parts of URL paths, use path.Join
• To build filesystem paths from path segments, use filepath.Join

How it works...

To build constant values, or for simple concatenations, use the + or += operators:

var TwoLines = "This is the first line \n"+
"This is the second line"
func ThreeLines(newLine string) string {
   return TwoLines+"\n"+newLine
}

You can add runes to a string the same way:

func AddNewLine(line string...

When working with textual data, problems related to string cases arise often. Should a text search be case-sensitive or case-insensitive? How do we convert a string to lowercase or uppercase? In this section, we will look at some recipes to deal with these common problems in a portable way.

How to do it...

• Convert strings to uppercase and lowercase using the strings.ToUpper and strings.ToLower functions, respectively.
• When dealing with text in languages with special uppercase/lowercase mappings (such as Turkish, where “İ” is the uppercase version of “I”), use strings.ToUpperSpecial and strings.ToLowerSpecial
• To convert text to uppercase for use in titles, use strings.ToTitle
• To compare strings lexicographically, use comparison operators
• To test the equivalence of strings ignoring case, use strings.EqualFold

How it works...

Converting a string to uppercase or lowercase is easy:

greet...

If there is a chance that your program will have to work with data produced by disparate systems, you should be aware of different text encodings. This is a huge topic, but this section should provide some pointers to scratch the surface.

How to do it...

• Use the golang.org/x/text/encoding package to deal with different encodings.
• To find an encoding by name, use one of the following:
  • golang.org/x/text/encoding/ianaindex
  • golang.org/x/text/encoding/htmlindex
• Once you have an encoding, use it to translate text to and from UTF-8.

How it works...

Use one of the indexes to find an encoding. Then, use that encoding to read/write data:

package main
import (
     "fmt"
     "os"
     "golang.org/x/text/encoding/ianaindex"
)
func main() {
     enc, err := ianaindex.MIME.Encoding("US-ASCII")
  ...

Go strings can be seen as a sequence of bytes, or as a sequence of runes. This section shows how you can iterate a string either way.

How to do it...

To iterate the bytes of a string, use indexes:

for i:=0;i<len(str);i++ {
  fmt.Print(str[i]," ")
}

To iterate the runes of a string, use range:

for index, c:=range str {
  fmt.Print(c," ")
}

How it works...

A Go string is a slice of bytes, so you would expect to be able to write a for-loop to iterate the bytes and runes of a string. You might think that you can do the following:

strBytes := []byte(str)
strRunes := []rune(str)

However, converting a string to a slice of bytes or a slice of runes is an expensive operation. The first one creates a writeable copy of the bytes of the str string, and the second one creates a writeable copy of the runes of str. Remember that rune is uint32.

There are two forms of for-loop to iterate the...

The strings package offers convenient functions to split a string to get a slice of strings.

How to do it...

• To split a string into components using a delimiter, use strings.Split.
• To split the space-separated components of a string, use strings.Fields.

How it works...

If you need to parse a string delimited with a fixed delimiter, use strings.Split. If you need to parse the space-separated sections of a string, use strings.Fields:

package main
import (
     "fmt"
     "strings"
)
func main() {
     fmt.Println(strings.Split("a,b,c,d", ","))
    // ["a", "b", "c", "d"]
     fmt.Println(strings.Split("a, b, c, d", ","))
    // ["a", " b", " c", " d"]
   &...

There are many use cases for processing strings in a stream, such as when dealing with large text or user input. This recipe shows the use of bufio.Scanner for this purpose.

How to do it...

• Use bufio.Scanner for reading lines, words, or custom blocks.
• Create a bufio.Scanner instance
• Set the split method
• Read scanned tokens in a for-loop

How it works...

The Scanner works like an iterator – every call to Scan() method will return true if it parsed the next token, or false if there are no more tokens. The token can be obtained by the Text() method:

package main
import (
     "bufio"
     "fmt"
     "strings"
)
const input = `This is a string
that has 3
lines.`
func main() {
     lineScanner := bufio.NewScanner(strings.NewReader(input))
     line...

User input is usually messy, including additional spaces before or after the text that matters. This recipe shows how to use the string trimming functions for this purpose.

How to do it...

Use the strings.Trim family of functions, as shown here:

package main
import (
     "fmt"
     "strings"
)
func main() {
     fmt.Println(strings.TrimRight("Break-------", "-"))
    // Break
     fmt.Println(strings.TrimRight("Break with spaces-- -- --", "- "))
    // Break with spaces
     fmt.Println(strings.TrimSuffix("file.txt", ".txt"))
    // file
     fmt.Println(strings.TrimLeft(" \t   Indented text", " \t"))
    ...

A regular expression offers efficient methods to ensure that textual data matches a given pattern, searches for patterns, extracts, and replaces parts of text. Usually, you compile a regular expression once and then use that compiled regular expression many times to efficiently validate, search, extract, or replace parts of strings.

Validating input

Format validation is the process of ensuring that data coming from user input or other sources is in a recognized format. Regular expressions can be an effective tool for such validation.

How to do it...

Use precompiled regular expressions to validate input values that should fit a pattern.

package main
import (
     "fmt"
     "regexp"
)
var integerRegexp = regexp.MustCompile("^[0-9]+$")
func main() {
     fmt.Println(integerRegexp.MatchString("123"))   // true
  ...

You can use a regular expression to locate and extract text that occurs within a pattern.

How to do it...

Use capture groups to extract substrings that match a pattern.

How it works...

package main
import (
     "fmt"
     "regexp"
)
func main() {
     re := regexp.MustCompile(`^(\w+)=(\w+)$`)
     result := re.FindStringSubmatch(`property=12`)
     fmt.Printf("Key: %s value: %s\n", result[1], result[2])
     result = re.FindStringSubmatch(`x=y`)
     fmt.Printf("Key: %s value: %s\n", result[1], result[2])
}

Here is the output:

Key: property value: 12
Key: x value: y

Let’s look at this regular expression:

• ^(\w+): A string composed of one or more word characters at the beginning of the line (capture group 1)
...

You can use a regular expression to search through text, replacing parts that match a pattern with other strings.

How to do it...

Use the Replace family of functions to replace the patterns in a string with something else:

package main
import (
     "fmt"
     "regexp"
)
func main() {
     // Find numbers, capture the first digit
     re := regexp.MustCompile(`([0-9])[0-9]*`)
     fmt.Println(re.ReplaceAllString("This example replaces 
     numbers  with 'x': 1, 100, 500.", "x"))
    // This example replaces numbers  with 'x': x, x, x.
     fmt.Println(re.ReplaceAllString("This example replaces all 
     numbers with their first digits: 1, 100, 500...

Templates are useful for generating data-driven textual output. The text/template package can be used in the following contexts:

• Configuration files: You can accept templates in configuration files, such as the following example that uses an env map variable to create environment-sensitive configurations

  logfile: {{.env.logDir}}/log.json

• Reporting: Use templates to generate output for command-line applications and reports
• Web applications: The html/template package provides HTML-safe templating functionality for template-based HTML generation to build web applications

Value substitution

The main use of templates is inserting data elements into structured text. This section describes how you can insert values computed in a program into a template.

How to do it...

Use the {{.name}} syntax to substitute a value in a template.

The following code segment executes a template using different inputs:

package main
import (
    ...

Template actions (i.e., the code elements placed in a template) may result in unwanted empty spaces and lines. The Go template system offers some mechanisms to deal with these unwanted spaces.

How to do it...

Use - next to the template delimiter:

• {{- will remove all spaces/tabs/newlines that were output before this template element
• -}} will remove all spaces/tabs/newlines that come after this template element

If a template directive produces output, such as the value of a variable, it will be written to the output stream. But if a template directive does not generate any output, such as a {{range}} or {{if}} statement, then it will be replaced with empty strings. And if those statements are on a line by themselves, those lines will be written to the output as well, like this:

{{range .}}
  {{if gt . 1}}
    {{.}}
  {{end}}
{{end}}

This template will produce an output every four lines. When...

As templates grow, they may become repetitive. To reduce such repetition, the Go template system offers named blocks (components) that can be reused within a template, just like functions in a program. Then, the final template can be composed of these components.

How to do it...

You can create template “components” that you can reuse in multiple contexts. To define a named template, use the {{define "name"}} construct:

{{define "template1"}}
  ...
{{end}}
{{define "template2"}}
 ...
{{end}}

Then, call that template using the {{template "name" .}} construct as if it is a function with a single argument:

{{template "template1" .}}
{{range .List}}
  {{template "template2" .}}
{{end}}

How it works...

The following example prints a book list using a named template:

package main
import (
     "os"
    ...

When developing web applications, it is usually desirable to have a few templates specifying page layouts. Complete web pages are constructed by combining page components, developed as independent templates using this layout. Unfortunately, the Go template engine forces you to think of alternative solutions because Go template references are static. This means you would need a separate layout template for each page.

But there are alternatives.

I’ll show you a basic idea that demonstrates how template composition can be used so that you can extend it, based on your use case, or how to use an available third-party library that does this. The crucial idea in composition using layout templates is that if you define a new template using an already-defined template name, the new definition overrides the older one.

How to do it...

• Create a layout template. Use empty templates or templates with default content for the sections...

The Go standard library documentation is always your best source for up-to-date information and great examples, such as the following:

• https://pkg.go.dev/strings
• https://pkg.go.dev/text/template
• https://pkg.go.dev/html/template
• https://pkg.go.dev/fmt
• https://pkg.go.dev/bufio

The following links are also useful:

• Character Model for the World Wide Web: String Matching: https://www.w3.org/TR/charmod-norm/
• Character Properties, Case Mappings & Names FAQ: https://unicode.org/faq/casemap_charprop.html
• RFC7564: PRECIS https://www.rfc-editor.org/rfc/rfc7564
• This is a great blog post about the Unicode normalization process: https://go.dev/blog/normalization
• For all encoding, internationalization, and Unicode-related problems that are not handled by the standard library, take a look at the packages here before searching for anything else: https://pkg.go.dev/golang.org/x/text