Package strutil contains some functions to manipulate string.
import (
"github.com/gozelle/lancet/strutil"
)
- After
- AfterLast
- Before
- BeforeLast
- CamelCase
- Capitalize
- IsString
- KebabCase
- UpperKebabCase
- LowerFirst
- UpperFirst
- Pad
- PadStart
- PadEnd
- Reverse
- SnakeCase
- UpperSnakeCase
- SplitEx
- Substring
- Wrap
- Unwrap
- SplitWords
- WordCount
- RemoveNonPrintable
- StringToBytes
- BytesToString
- IsBlank
- HasPrefixAny
- HasSuffixAny
- IndexOffset
Returns the substring after the first occurrence of a specified string in the source string.
Signature:
func After(s, char string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.After("foo", "")
result2 := strutil.After("foo", "foo")
result3 := strutil.After("foo/bar", "foo")
result4 := strutil.After("foo/bar", "/")
result5 := strutil.After("foo/bar/baz", "/")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
// Output:
// foo
//
// /bar
// bar
// bar/baz
}
Returns the substring after the last occurrence of a specified string in the source string.
Signature:
func AfterLast(s, char string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.AfterLast("foo", "")
result2 := strutil.AfterLast("foo", "foo")
result3 := strutil.AfterLast("foo/bar", "/")
result4 := strutil.AfterLast("foo/bar/baz", "/")
result5 := strutil.AfterLast("foo/bar/foo/baz", "foo")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
// Output:
// foo
//
// bar
// baz
// /baz
}
Returns the substring of the source string up to the first occurrence of the specified string.
Signature:
func Before(s, char string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.Before("foo", "")
result2 := strutil.Before("foo", "foo")
result3 := strutil.Before("foo/bar", "/")
result4 := strutil.Before("foo/bar/baz", "/")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
// Output:
// foo
//
// foo
// foo
}
Returns the substring of the source string up to the last occurrence of the specified string.
Signature:
func BeforeLast(s, char string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.BeforeLast("foo", "")
result2 := strutil.BeforeLast("foo", "foo")
result3 := strutil.BeforeLast("foo/bar", "/")
result4 := strutil.BeforeLast("foo/bar/baz", "/")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
// Output:
// foo
//
// foo
// foo/bar
}
Coverts string to camelCase string, non letters and numbers will be ignored.
Signature:
func CamelCase(s string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
strings := []string{"", "foobar", "&FOO:BAR$BAZ", "$foo%", "Foo-#1😄$_%^&*(1bar"}
for _, v := range strings {
s := strutil.CamelCase(v)
fmt.Println(s)
}
// Output:
//
// foobar
// fooBarBaz
// foo
// foo11Bar
}
KebabCase covert string to kebab-case, non letters and numbers will be ignored.
Signature:
func KebabCase(s string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
strings := []string{"", "foo-bar", "Foo Bar-", "FOOBAR", "Foo-#1😄$_%^&*(1bar"}
for _, v := range strings {
s := strutil.KebabCase(v)
fmt.Println(s)
}
// Output:
//
// foo-bar
// foo-bar
// foobar
// foo-1-1-bar
}
UpperKebabCase covert string to upper KEBAB-CASE, non letters and numbers will be ignored.
Signature:
func UpperKebabCase(s string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
strings := []string{"", "foo-bar", "Foo Bar-", "FooBAR", "Foo-#1😄$_%^&*(1bar"}
for _, v := range strings {
s := strutil.UpperKebabCase(v)
fmt.Println(s)
}
// Output:
//
// FOO-BAR
// FOO-BAR
// FOO-BAR
// FOO-1-1-BAR
}
Convert the first character of a string to upper case.
Signature:
func Capitalize(s string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
strings := []string{"", "Foo", "_foo", "fooBar", "foo-bar"}
for _, v := range strings {
s := strutil.Capitalize(v)
fmt.Println(s)
}
// Output:
//
// Foo
// _foo
// Foobar
// Foo-bar
}
Check if the value's data type is string.
Signature:
func IsString(v any) bool
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.IsString("")
result2 := strutil.IsString("a")
result3 := strutil.IsString(1)
result4 := strutil.IsString(true)
result5 := strutil.IsString([]string{"a"})
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
// Output:
// true
// true
// false
// false
// false
}
Convert the first character of string to lower case.
Signature:
func LowerFirst(s string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
strings := []string{"", "bar", "BAr", "Bar大"}
for _, v := range strings {
s := strutil.LowerFirst(v)
fmt.Println(s)
}
// Output:
//
// bar
// bAr
// bar大
}
Convert the first character of string to upper case.
Signature:
func UpperFirst(s string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
strings := []string{"", "bar", "BAr", "bar大"}
for _, v := range strings {
s := strutil.UpperFirst(v)
fmt.Println(s)
}
// Output:
//
// Bar
// BAr
// Bar大
}
Pads string on the left and right side if it's shorter than size.
Signature:
func Pad(source string, size int, padStr string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.Pad("foo", 1, "bar")
result2 := strutil.Pad("foo", 2, "bar")
result3 := strutil.Pad("foo", 3, "bar")
result4 := strutil.Pad("foo", 4, "bar")
result5 := strutil.Pad("foo", 5, "bar")
result6 := strutil.Pad("foo", 6, "bar")
result7 := strutil.Pad("foo", 7, "bar")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
fmt.Println(result6)
fmt.Println(result7)
// Output:
// foo
// foo
// foo
// foob
// bfoob
// bfooba
// bafooba
}
Pads string on the right side if it's shorter than size.
Signature:
func PadEnd(source string, size int, padStr string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.PadEnd("foo", 1, "bar")
result2 := strutil.PadEnd("foo", 2, "bar")
result3 := strutil.PadEnd("foo", 3, "bar")
result4 := strutil.PadEnd("foo", 4, "bar")
result5 := strutil.PadEnd("foo", 5, "bar")
result6 := strutil.PadEnd("foo", 6, "bar")
result7 := strutil.PadEnd("foo", 7, "bar")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
fmt.Println(result6)
fmt.Println(result7)
// Output:
// foo
// foo
// foo
// foob
// fooba
// foobar
// foobarb
}
Pads string on the left side if it's shorter than size.
Signature:
func PadStart(source string, size int, padStr string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.PadStart("foo", 1, "bar")
result2 := strutil.PadStart("foo", 2, "bar")
result3 := strutil.PadStart("foo", 3, "bar")
result4 := strutil.PadStart("foo", 4, "bar")
result5 := strutil.PadStart("foo", 5, "bar")
result6 := strutil.PadStart("foo", 6, "bar")
result7 := strutil.PadStart("foo", 7, "bar")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
fmt.Println(result6)
fmt.Println(result7)
// Output:
// foo
// foo
// foo
// bfoo
// bafoo
// barfoo
// barbfoo
}
Return string whose char order is reversed to the given string.
Signature:
func Reverse(s string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
s := "foo"
rs := strutil.Reverse(s)
fmt.Println(s)
fmt.Println(rs)
// Output:
// foo
// oof
}
Coverts string to snake_case, non letters and numbers will be ignored.
Signature:
func SnakeCase(s string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
strings := []string{"", "foo-bar", "Foo Bar-", "FOOBAR", "Foo-#1😄$_%^&*(1bar"}
for _, v := range strings {
s := strutil.SnakeCase(v)
fmt.Println(s)
}
// Output:
//
// foo_bar
// foo_bar
// foobar
// foo_1_1_bar
}
Coverts string to upper KEBAB-CASE, non letters and numbers will be ignored.
Signature:
func SnakeCase(s string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
strings := []string{"", "foo-bar", "Foo Bar-", "FooBAR", "Foo-#1😄$_%^&*(1bar"}
for _, v := range strings {
s := strutil.UpperSnakeCase(v)
fmt.Println(s)
}
// Output:
//
// FOO_BAR
// FOO_BAR
// FOO_BAR
// FOO_1_1_BAR
}
Split a given string whether the result contains empty string.
Signature:
func SplitEx(s, sep string, removeEmptyString bool) []string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.SplitEx(" a b c ", "", true)
result2 := strutil.SplitEx(" a b c ", " ", false)
result3 := strutil.SplitEx(" a b c ", " ", true)
result4 := strutil.SplitEx("a = b = c = ", " = ", false)
result5 := strutil.SplitEx("a = b = c = ", " = ", true)
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
// Output:
// []
// [ a b c ]
// [a b c]
// [a b c ]
}
Returns a substring of the specified length starting at the specified offset position.
Signature:
func Substring(s string, offset int, length uint) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.Substring("abcde", 1, 3)
result2 := strutil.Substring("abcde", 1, 5)
result3 := strutil.Substring("abcde", -1, 3)
result4 := strutil.Substring("abcde", -2, 2)
result5 := strutil.Substring("abcde", -2, 3)
result6 := strutil.Substring("你好,欢迎你", 0, 2)
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
fmt.Println(result6)
// Output:
// bcd
// bcde
// e
// de
// de
// 你好
}
Wrap a string with given string.
Signature:
func Wrap(str string, wrapWith string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.Wrap("foo", "")
result2 := strutil.Wrap("foo", "*")
result3 := strutil.Wrap("'foo'", "'")
result4 := strutil.Wrap("", "*")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
// Output:
// foo
// *foo*
// ''foo''
//
}
Unwrap a given string from anther string. will change source string.
Signature:
func Unwrap(str string, wrapToken string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.Unwrap("foo", "")
result2 := strutil.Unwrap("*foo*", "*")
result3 := strutil.Unwrap("*foo", "*")
result4 := strutil.Unwrap("foo*", "*")
result5 := strutil.Unwrap("**foo**", "*")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
// Output:
// foo
// foo
// *foo
// foo*
// *foo*
}
Splits a string into words, word only contains alphabetic characters.
Signature:
func SplitWords(s string) []string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.SplitWords("a word")
result2 := strutil.SplitWords("I'am a programmer")
result3 := strutil.SplitWords("Bonjour, je suis programmeur")
result4 := strutil.SplitWords("a -b-c' 'd'e")
result5 := strutil.SplitWords("你好,我是一名码农")
result6 := strutil.SplitWords("こんにちは,私はプログラマーです")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
fmt.Println(result6)
// Output:
// [a word]
// [I'am a programmer]
// [Bonjour je suis programmeur]
// [a b-c' d'e]
// []
// []
}
Return the number of meaningful word, word only contains alphabetic characters.
Signature:
func WordCount(s string) int
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.WordCount("a word")
result2 := strutil.WordCount("I'am a programmer")
result3 := strutil.WordCount("Bonjour, je suis programmeur")
result4 := strutil.WordCount("a -b-c' 'd'e")
result5 := strutil.WordCount("你好,我是一名码农")
result6 := strutil.WordCount("こんにちは,私はプログラマーです")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
fmt.Println(result6)
// Output:
// 2
// 3
// 4
// 3
// 0
// 0
}
Remove non-printable characters from a string.
Signature:
func RemoveNonPrintable(str string) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.RemoveNonPrintable("hello\u00a0 \u200bworld\n")
result2 := strutil.RemoveNonPrintable("你好😄")
fmt.Println(result1)
fmt.Println(result2)
// Output:
// hello world
// 你好😄
}
Converts a string to byte slice without a memory allocation.
Signature:
func StringToBytes(str string) (b []byte)
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.StringToBytes("abc")
result2 := reflect.DeepEqual(result1, []byte{'a', 'b', 'c'})
fmt.Println(result1)
fmt.Println(result2)
// Output:
// [97 98 99]
// true
}
Converts a byte slice to string without a memory allocation.
Signature:
func BytesToString(bytes []byte) string
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
bytes := []byte{'a', 'b', 'c'}
result := strutil.BytesToString(bytes)
fmt.Println(result)
// Output:
// abc
}
Checks if a string is whitespace or empty.
Signature:
func IsBlank(str string) bool
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.IsBlank("")
result2 := strutil.IsBlank("\t\v\f\n")
result3 := strutil.IsBlank(" 中文")
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
// Output:
// true
// true
// false
}
Checks if a string starts with any of an array of specified strings.
Signature:
func HasPrefixAny(str string, prefixes []string) bool
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.HasPrefixAny("foo bar", []string{"fo", "xyz", "hello"})
result2 := strutil.HasPrefixAny("foo bar", []string{"oom", "world"})
fmt.Println(result1)
fmt.Println(result2)
// Output:
// true
// false
}
Checks if a string ends with any of an array of specified strings.
Signature:
func HasSuffixAny(str string, suffixes []string) bool
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
result1 := strutil.HasSuffixAny("foo bar", []string{"bar", "xyz", "hello"})
result2 := strutil.HasSuffixAny("foo bar", []string{"oom", "world"})
fmt.Println(result1)
fmt.Println(result2)
// Output:
// true
// false
}
Returns the index of the first instance of substr in string after offsetting the string by `idxFrom`, or -1 if substr is not present in string.
Signature:
func IndexOffset(str string, substr string, idxFrom int) int
Example:
import (
"fmt"
"github.com/gozelle/lancet/strutil"
)
func main() {
str := "foo bar hello world"
result1 := strutil.IndexOffset(str, "o", 5)
result2 := strutil.IndexOffset(str, "o", 0)
result3 := strutil.IndexOffset(str, "d", len(str)-1)
result4 := strutil.IndexOffset(str, "d", len(str))
result5 := strutil.IndexOffset(str, "f", -1)
fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)
// Output:
// 12
// 1
// 18
// -1
// -1
}