Strings and Text

Post Example
Examples in Go
Create a Random String in Go
by yhuang Go fmt fmt.Println math/rand rand.New rand.NewSource 
package main

import (
	"fmt"
	"math/rand"
	"time"
)

var r = rand.New(rand.NewSource(time.Now().UnixNano()))

func RandomString(strlen int) string {
	const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
	result := make([]byte, strlen)
	for i := range result {
		result[i] = chars[r.Intn(len(chars))]
	}
	return string(result)
}

func main() {
	fmt.Println(RandomString(10))
}

Last Run  :
BFDoNyBToC
String Concatenation in Go
by yhuang Go fmt.Println strings.Builder.WriteString fmt strings strings.Builder 
package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "Hello"
	t := s + " World"
	fmt.Println(t)

	// Using a builder
	var b strings.Builder
	b.WriteString("Good")
	b.WriteString("Bye\n")
	fmt.Println(b.String())
}
Contains Substring in Go
by yhuang Go fmt fmt.Println strings strings.Contains 
package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println("Contains:  ", strings.Contains("test", "es"))
}
Last Run  :
Contains:   true
Count Substring Instances in Go
by yhuang Go fmt.Println strings.Count fmt strings 
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Count("cheese", "e"))
	fmt.Println(strings.Count("five", "")) // before & after each rune
}
Has Prefix in Go
by yhuang Go fmt.Println strings.HasPrefix fmt strings 
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.HasPrefix("Gopher", "Go"))
	fmt.Println(strings.HasPrefix("Gopher", "C"))
	fmt.Println(strings.HasPrefix("Gopher", ""))
}
Has Suffix in Go
by yhuang Go fmt.Println strings.HasSuffix fmt strings 
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.HasSuffix("Amigo", "go"))
	fmt.Println(strings.HasSuffix("Amigo", "O"))
	fmt.Println(strings.HasSuffix("Amigo", "Ami"))
	fmt.Println(strings.HasSuffix("Amigo", ""))
}
Last Run  :
true
false
false
true
Index of Substring in Go
by yhuang Go fmt.Println strings.Index fmt strings 
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Index("chicken", "ken"))
	fmt.Println(strings.Index("chicken", "dmr"))
}
Join Strings in Go
by yhuang Go fmt fmt.Println strings strings.Join
Join concatenates a list of strings to create a single string. A separator is placed between elements in the resulting string.
package main

import (
	"fmt"
	"strings"
)

func main() {
	s := []string{"foo", "bar", "baz"}
	fmt.Println(strings.Join(s, ", "))
}
Last Run  :
foo, bar, baz
Repeat Substring in Go
by yhuang Go fmt fmt.Println strings strings.Repeat
Creates a new string consisting of a substring repeated a certain number of times.
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println("ba" + strings.Repeat("na", 2))
}
Replace Substring in Go
by yhuang Go fmt.Println strings.Replace fmt strings
Creates a string that has non overlapping instances of a substring replaced by a new string.
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
	fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
}
Split String with Multiple Delimiters in Go
by yhuang Go fmt fmt.Println strings strings.FieldsFunc
Splits a string into substrings separated by a given separator substring.
package main

import (
	"fmt"
	"strings"
)

func main() {
	input := `xxxxx:yyyyy:zzz.aaa.bbb.cc:dd:ee:ff`
	a := strings.FieldsFunc(input, Split)
	fmt.Println(a)
}
func Split(r rune) bool {
	return r == ':' || r == '.'
}

Last Run  :
[xxxxx yyyyy zzz aaa bbb cc dd ee ff]
To Lowercase in Go
by yhuang Go fmt fmt.Println strings strings.ToLower
Creates a string with all Unicode letters from the original string mapped to their lower case.
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToLower("Gopher"))
}
Last Run  :
gopher
To Uppercase in Go
by yhuang Go fmt fmt.Println strings strings.ToUpper
Creates a string with all Unicode letters from the original string mapped to their upper case.
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToUpper("Gopher"))
}
Last Run  :
GOPHER
Get Length in Go
by yhuang Go fmt fmt.Println
Returns the number of characters in the string.
package main

import (
	"fmt"
)

func main() {
	fmt.Println(len("Gopher"))
}
Get Character at Index in Go
by yhuang Go fmt fmt.Println 
package main

import (
	"fmt"
)

func main() {
	fmt.Println("Char:", "hello"[1])
}
Compile Regex in Go
by yhuang Go fmt.Println fmt regexp regexp.MustCompile 
package main

import (
	"fmt"
	"regexp"
)

func main() {
	// Compile the expression once, usually at init time.
	// Use raw strings to avoid having to quote the backslashes.
	var validID = regexp.MustCompile(`^[a-z]+\[[0-9]+\]$`)

	fmt.Println(validID.MatchString("adam[23]"))
	fmt.Println(validID.MatchString("eve[7]"))
	fmt.Println(validID.MatchString("Job[48]"))
	fmt.Println(validID.MatchString("snakey"))
}

Last Run  :
true
true
false
false
String Formatting in Go
by yhuang Go fmt.Printf fmt fmt.Fprintf fmt.Println fmt.Sprintf
Go offers excellent support for string formatting in the printf tradition. Here are some examples of common string formatting tasks.
package main

import (
    "fmt"
    "os"
)

type point struct {
    x, y int
}

func main() {
  
    // In these examples we use fmt.Printf to directly output the result on stdout.
    // If you wanted to create a string result to be used in a different way,
    // you can use fmt.Sprintf instead.

    p := point{1, 2}
    fmt.Printf("%v\n", p)

    fmt.Printf("%+v\n", p)

    fmt.Printf("%#v\n", p)

    fmt.Printf("%T\n", p)

    fmt.Printf("%t\n", true)

    fmt.Printf("%d\n", 123)

    fmt.Printf("%b\n", 14)

    fmt.Printf("%c\n", 33)

    fmt.Printf("%x\n", 456)

    fmt.Printf("%f\n", 78.9)

    fmt.Printf("%e\n", 123400000.0)
    fmt.Printf("%E\n", 123400000.0)

    fmt.Printf("%s\n", "\"string\"")

    fmt.Printf("%q\n", "\"string\"")

    fmt.Printf("%x\n", "hex this")

    fmt.Printf("%p\n", &p)

    fmt.Printf("|%6d|%6d|\n", 12, 345)

    fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)

    fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)

    fmt.Printf("|%6s|%6s|\n", "foo", "b")

    fmt.Printf("|%-6s|%-6s|\n", "foo", "b")

    s := fmt.Sprintf("a %s", "string")
    fmt.Println(s)

    fmt.Fprintf(os.Stderr, "an %s\n", "error")
}
Remove All Whitespace in Go
by yhuang Go fmt fmt.Println strings strings.Fields strings.Join 
package main

import (
  "strings"
  "fmt"
)

func main() {
  s := "Some string with  \n\t whitespace"
  fmt.Println(strings.Join(strings.Fields(s),""))
}
Filter to AlphaNumerics in Go
by yhuang Go fmt fmt.Println regexp regexp.Compile 
package main

import (
    "fmt"
    "regexp"
)

func main() {

    example := "#GoLangCode!$!"

    // Make a Regex to say we only want letters and numbers
    reg, err := regexp.Compile("[^a-zA-Z0-9]+")
    if err != nil {
      panic(err)
    }
    processedString := reg.ReplaceAllString(example, "")

    fmt.Println(processedString)
}
Compare Strings in Go
by yhuang Go fmt.Println strings.Compare fmt strings 
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Compare("a", "b"))
	fmt.Println(strings.Compare("a", "a"))
	fmt.Println(strings.Compare("b", "a"))
}
Append Character to String in Go
by yhuang Go fmt fmt.Println 
package main

import "fmt"

func main() {
	fmt.Println("string" + string('c'))
}
String Builder in Go
by yhuang Go fmt fmt.Fprintf fmt.Println strings strings.Builder 
package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder
	for i := 3; i >= 1; i-- {
		fmt.Fprintf(&b, "%d...", i)
	}
	b.WriteString("ignition")
	fmt.Println(b.String())
}

Last Run  :
3...2...1...ignition
Join Integers in Go
by yhuang Go fmt fmt.Println fmt.Sprint strings strings.Join 
package main

import (
	"fmt"
	"strings"
)

func main() {
	a := []int{1, 2, 3}
	str := fmt.Sprint(a)
	joined := strings.Join(strings.Split(str[1:len(str)-1], " "), "++")
	fmt.Println(joined)
}

Last Run  :
1++2++3