What are the libraries to manipulate string in Go programming language?

In the Go programming language, string manipulation functionality is primarily handled by several standard libraries, which provide a comprehensive set of functions for processing strings. Here are some of the most commonly used packages:

1. strings package: This is one of the most fundamental and widely used packages for string manipulation in Go. It offers numerous functions for querying and manipulating strings. For example, strings.Contains checks if a string contains a substring, strings.Join concatenates multiple strings into one, and strings.ToUpper and strings.ToLower convert strings to uppercase or lowercase, respectively.

Example:

go
import "strings"

func Example() {
    // String splitting
    fmt.Println(strings.Split("a,b,c", ",")) // Output: [a b c]

    // String containment
    fmt.Println(strings.Contains("hello", "ll")) // Output: true

    // String to uppercase
    fmt.Println(strings.ToUpper("hello")) // Output: HELLO
}

1. bytes package: Although this package is primarily designed for manipulating byte slices ([]byte), it is frequently used for string processing in Go because strings can easily be converted to byte slices. Functions such as bytes.Compare and bytes.Contains are commonly utilized.

Example:

go
import "bytes"

func Example() {
    // String comparison
    fmt.Println(bytes.Compare([]byte("hello"), []byte("world"))) // Output: -1

    // Byte slice containment
    fmt.Println(bytes.Contains([]byte("hello"), []byte("ll"))) // Output: true
}

1. strconv package: This package is mainly used for converting strings to and from basic data types. For example, strconv.Atoi converts a string to an integer, and strconv.FormatFloat converts a float to a string.

Example:

go
import "strconv"

func Example() {
    // String to integer
    i, _ := strconv.Atoi("123")
    fmt.Println(i) // Output: 123

    // Integer to string
    s := strconv.Itoa(123)
    fmt.Println(s) // Output: "123"
}

1. unicode and unicode/utf8 packages: These packages provide support for Unicode characters. They assist with handling UTF-8 encoded strings, detecting character categories, and more.

Example:

go
import "unicode"

func Example() {
    // Check if it's a letter
    fmt.Println(unicode.IsLetter('a')) // Output: true
    fmt.Println(unicode.IsLetter('1')) // Output: false
}

Combining these packages can address most string manipulation requirements, ranging from basic processing to complex encoding-related issues.