Golang Strings And Runes Complete Guide

1. What are Strings in GoLang?

Answer: In GoLang, strings are sequences of bytes and are immutable, meaning that once a string is created, it cannot be changed. Typically, strings in Go are UTF-8 encoded, so they can represent any Unicode character.

s := "Hello, World!"
fmt.Println(s) // Output: Hello, World!

2. How are Strings different from Runes in GoLang?

Answer: While strings are sequences of bytes, runes are numeric values representing Unicode code points. A rune is just an alias for int32, and it represents a single Unicode character.

r := '👋' // This is a rune
fmt.Printf("%U\n", r) // Output: U+1F44B

Strings in Go are built out of these runes, especially when dealing with text that contains characters outside the ASCII range.

3. How do you convert a String to a Slice of runes in GoLang?

Answer: To convert a string to a slice of runes, you should use a type conversion:

s := "👋🌍"
runes := []rune(s)
fmt.Println(runes)
// Output will be something like: [128075 127759]

This helps in accurately processing multi-byte characters, such as emojis in this example.

4. How do you concatenate two or more strings in GoLang?

Answer: Concatenating strings can be done in multiple ways in Go. The simplest way is using the + operator. For more efficient concatenation, especially in loops, consider using strings.Builder.

Using + Operator:

s1 := "Hello"
s2 := ", World!"
result := s1 + s2
fmt.Println(result) // Output: Hello, World!

Using strings.Builder:

var builder strings.Builder
builder.WriteString("Hello")
builder.WriteString(", World!")
result := builder.String()
fmt.Println(result) // Output: Hello, World!

5. How do you get the length of a string in GoLang?

Answer: The len() function gives you the number of bytes in a string, not the number of characters. To get the real character count, convert the string to a slice of runes and then take its length.

s := "👋🌍"
byteLen := len(s)
runeLen := len([]rune(s))
fmt.Println(byteLen) // Output: 10
fmt.Println(runeLen) // Output: 2

Note the difference between byte length (10) and rune length (2).

6. What are some common methods available on the strings package in GoLang?

Answer: The strings package provides many functions for manipulating and inspecting strings:

• Contains(s, substr string) bool: Checks if s contains substr.
• Fields(s string) []string: Splits the string into fields separated by whitespace.
• Join(elems []string, sep string) string: Joins a slice of strings with the specified separator.
• ToUpper/ToLower(s string) string: Converts the whole string to uppercase/lowercase.
• TrimSpace(s string) string: Removes leading and trailing whitespace from s.
• Split(s, sep string) []string: Splits the string into substrings separated by sep.

Example:

s := "Hello,World!"
parts := strings.Split(s, ",")
fmt.Println(parts[0]) // Output: Hello
fmt.Println(parts[1]) // Output: World!

7. How do you check if a string has a specific prefix/suffix in GoLang?

Answer: Use the strings.HasPrefix() and strings.HasSuffix() functions.

s := "Hello, World!"
if strings.HasPrefix(s, "Hello") {
    fmt.Println("Starts with Hello")
}
if strings.HasSuffix(s, "World!") {
    fmt.Println("Ends with World!")
}

8. Can you show how to iterate over the characters in a string properly in GoLang?

Answer: To correctly iterate over characters (runes) in a multi-byte string:

s := "👋🌍"
for _, r := range s {
    fmt.Printf("%c\n", r) 
}
// Output:
// 👋
// 🌍

Here, range iterates over each rune in the string s.

9. How do you compare two strings in GoLang for equality?

Answer: Simply use the == operator for case-sensitive comparison or the Unicode normalization functions from golang.org/x/text/unicode/norm for more advanced comparison.

s1 := "Hello"
s2 := "Hello"
s3 := "hello"

fmt.Println(s1 == s2) // Output: true
fmt.Println(s1 == s3) // Output: false (case matters)

For case-insensitive comparison:

import (
    "strings"
)

func isEqualIgnoreCase(s1, s2 string) bool {
    return strings.EqualFold(s1, s2)
}

fmt.Println(isEqualIgnoreCase("Hello", "hello")) // Output: true

10. How do you find all matches of a regular expression in a string using GoLang?

Answer: For finding all matches of a regular expression within a string, you can use the regexp package and its FindAllString() method.

Example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    s := "Go provides powerful regular expressions."
    re := regexp.MustCompile(`o`)
    all := re.FindAllString(s, -1)
    fmt.Println(all) // Output: [o o o]
}

Using FindAllString(s, -1) returns every match of the pattern within the string s. If you wish to limit the number of results, you can specify a non-negative integer instead of -1.