Strings package in Golang

Overview

In this lesson on String package in Golang, we will study various examples on managing Strings and see how Strings package helps us in regards to Strings Handling in Go programming language. We will get started now.

Starting with Go

Just to make sure we are on the right track of running Go programs, here is the directory structure which I made for my Hello World program:

package main

import "fmt"

func main() {
fmt.Printf("Hello, world.n")
}

We can run the above program with following command:

go run hello.go

Once we run this command, here is the output you will see:

Now that looks good. Let’s move to our main agenda.

String Handling

Let’s start our journey of handling Strings in Go. We will be exploring the strings package in Go to study various examples. Let’s get started.

Comparing Strings

Comparing Strings is the most common operation done in the any programming language actually. Let’s look at some code snippet now:

package main

import (
"fmt"
"strings"
)

func main() {
var str1 string = "Shubham"
var str2 string = "Linux"
var str3 string = "linux"
var str4 string = "Linux"

fmt.Println(strings.Compare(str1, str2))
fmt.Println(strings.Compare(str2, str3))
fmt.Println(strings.Compare(str4, str2))
}

Again, we can run the above program with following command:

go run StringCompare.go

Once we run this command, here is the output you will see:

So, here is the output explained:

1 appears as the first String comes after the second String alphabetically
-1 comes as ‘Linux’ comes before ‘linux’ when ASCII values are compared
comes when String objects are found to be exactly the same

Containing Strings

Now, we will check if a String is a substring of another String. Let’s look at some code snippet now:

package main

import (
"fmt"
"strings"
)

func main() {
var mainString string = "Linux"
fmt.Println(strings.Contains(mainString, "ux"))
fmt.Println(strings.Contains(mainString, "UX"))
fmt.Println(strings.Contains(mainString, "Lin"))
}

Again, we can run the above program with following command:

go run StringContains.go

Once we run this command, here is the output you will see:

In this case, output is self-explanatory.

Index of Substring

We can also find the index where the given substring is found first. Let’s look at some code snippet now:

package main

import (
"fmt"
"strings"
)

func main() {
var mainString string = "Shubham"
var subs string = "bha"

fmt.Println(strings.Index(mainString, subs))
}

We can run the above program with following command:

go run StringIndex.go

Once we run this command, here is the output you will see:

Replacing part of Strings

We can replace part of Strings in Go as well. Let’s look at some code snippet now:

package main

import "fmt"
import s "strings"

func main() {
var mainString string = "Linux"
var toReplace string = "Li"
var newPart string = "Te"

fmt.Println(s.Replace(mainString, toReplace, newPart, –1))
}

In above program, we also saw a slightly different way of importing a package and assigning it an alias name. We can run the above program with following command:

go run StringReplace.go

Once we run this command, here is the output you will see:

Splitting Strings

We can even break Strings in Go by providing a common pattern which might be occurring. Here is an example:

package main

import "fmt"
import s "strings"

func main() {
var mainString string = "L-i-n-u-x"
var splitter string = "-"
fmt.Println(s.Split(mainString, splitter))
}

We can run the above program with following command:

go run StringSplit.go

Once we run this command, here is the output you will see:

Conclusion

To study, Strings package in Go is very deep and it is never possible to get enough. Read more examples for the package and try as much as possible on your own.

golang