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  :
veW4OiszFm

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())
}

String Interpolation in V

by yhuang V

name := 'Bob'
println('Hello, $name!')  // `$` is used for string interpolation

Last Run  :
Hello, Bob!

Contains Substring in JavaScript

by yhuang JavaScript

var str = "Hello world, welcome to the universe.";
console.log(str.includes("world"));
console.log(str.includes("pig"));

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 JavaScript

by yhuang JavaScript

var str = "Hello world";
console.log(str.startsWith("Hello"));

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 Zig

by blogscot Zig

Creates a string with all Unicode letters from the original string mapped to their lower case.

const std = @import("std");

pub fn main() void {
    var buf: [20]u8 = undefined;
    const output = std.ascii.lowerString(&buf, "Hello World!");
    std.debug.print("{s}", .{output});
}

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

Strings and Text

Filter by Language