Introduction
Strings in Go are sequences of characters. They are immutable, meaning that once a string is created, its value cannot be changed. Go provides a rich set of functions and methods for working with strings, making it easy to manipulate and process text. In this chapter, you will learn the basics of strings in Go, including how to create, manipulate, and perform common operations on strings.
Creating Strings
Basic String Declaration
Strings in Go are declared using double quotes (").
Example:
package main
import "fmt"
func main() {
var str1 string = "Hello, World!"
str2 := "Hello, Go!"
fmt.Println(str1) // Output: Hello, World!
fmt.Println(str2) // Output: Hello, Go!
}
Multiline Strings
Multiline strings are created using backticks (`), which preserve the formatting, including line breaks and spaces.
Example:
package main
import "fmt"
func main() {
multiline := `This is a multiline string.
It spans multiple lines.
Tabs and spaces are preserved.`
fmt.Println(multiline)
}
String Operations
String Length
The len function returns the length of a string in bytes.
Example:
package main
import "fmt"
func main() {
str := "Hello, World!"
fmt.Println(len(str)) // Output: 13
}
Accessing Characters
You can access individual characters in a string using indexing. Note that this returns the byte at the specified index, not the character.
Example:
package main
import "fmt"
func main() {
str := "Hello, World!"
fmt.Println(str[0]) // Output: 72 (ASCII value of 'H')
fmt.Printf("%c\n", str[0]) // Output: H
}
Iterating Over Characters
You can iterate over the characters in a string using a for–range loop.
Example:
package main
import "fmt"
func main() {
str := "Hello, Go!"
for index, char := range str {
fmt.Printf("Index: %d, Character: %c\n", index, char)
}
}
String Concatenation
Strings can be concatenated using the + operator.
Example:
package main
import "fmt"
func main() {
str1 := "Hello, "
str2 := "Go!"
result := str1 + str2
fmt.Println(result) // Output: Hello, Go!
}
String Comparison
Strings can be compared using the comparison operators (==, !=, <, >, <=, >=).
Example:
package main
import "fmt"
func main() {
str1 := "Hello"
str2 := "Go"
fmt.Println(str1 == str2) // Output: false
fmt.Println(str1 != str2) // Output: true
fmt.Println(str1 > str2) // Output: false
}
Substring
You can extract a substring using slicing.
Example:
package main
import "fmt"
func main() {
str := "Hello, World!"
substr := str[7:12]
fmt.Println(substr) // Output: World
}
Common String Functions
The strings package provides many useful functions for working with strings.
Importing the Strings Package
To use the functions in the strings package, you need to import it.
Example:
import "strings"
Contains
The Contains function checks if a substring is present in a string.
Example:
package main
import (
"fmt"
"strings"
)
func main() {
str := "Hello, World!"
fmt.Println(strings.Contains(str, "World")) // Output: true
}
Split
The Split function splits a string into a slice of substrings based on a delimiter.
Example:
package main
import (
"fmt"
"strings"
)
func main() {
str := "Hello, World!"
parts := strings.Split(str, ", ")
fmt.Println(parts) // Output: [Hello World!]
}
Join
The Join function joins a slice of strings into a single string with a specified separator.
Example:
package main
import (
"fmt"
"strings"
)
func main() {
parts := []string{"Hello", "World!"}
str := strings.Join(parts, ", ")
fmt.Println(str) // Output: Hello, World!
}
Replace
The Replace function replaces occurrences of a substring within a string with another substring.
Example:
package main
import (
"fmt"
"strings"
)
func main() {
str := "Hello, World!"
newStr := strings.Replace(str, "World", "Go", 1)
fmt.Println(newStr) // Output: Hello, Go!
}
ToUpper and ToLower
The ToUpper and ToLower functions convert a string to uppercase or lowercase.
Example:
package main
import (
"fmt"
"strings"
)
func main() {
str := "Hello, World!"
fmt.Println(strings.ToUpper(str)) // Output: HELLO, WORLD!
fmt.Println(strings.ToLower(str)) // Output: hello, world!
}
Conclusion
Strings in Go are powerful and flexible, with a rich set of functions for manipulation and processing. By understanding how to create, manipulate, and perform common operations on strings, you can effectively handle text in your Go programs. The strings package provides many useful functions that make working with strings easier and more efficient.