mirror of
https://github.com/duke-git/lancet.git
synced 2026-02-04 21:02:27 +08:00
13 KiB
13 KiB
Strutil
Package strutil contains some functions to manipulate string.
Source:
Usage:
import (
"github.com/duke-git/lancet/v2/strutil"
)
Index
- After
- AfterLast
- Before
- BeforeLast
- CamelCase
- Capitalize
- IsString
- KebabCase
- UpperKebabCase
- LowerFirst
- UpperFirst
- PadEnd
- PadStart
- Reverse
- SnakeCase
- UpperSnakeCase
- SplitEx
- Substring
- Wrap
- Unwrap
Documentation
After
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/duke-git/lancet/v2/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
}
AfterLast
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/duke-git/lancet/v2/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
}
Before
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/duke-git/lancet/v2/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
}
BeforeLast
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/duke-git/lancet/v2/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
}
CamelCase
Coverts string to camelCase string, non letters and numbers will be ignored.
Signature:
func CamelCase(s string) string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/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
KebabCase covert string to kebab-case, non letters and numbers will be ignored.
Signature:
func KebabCase(s string) string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/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
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/duke-git/lancet/v2/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
}
Capitalize
Convert the first character of a string to upper case.
Signature:
func Capitalize(s string) string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/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
}
IsString
Check if the value's data type is string.
Signature:
func IsString(v any) bool
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/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
}
LowerFirst
Convert the first character of string to lower case.
Signature:
func LowerFirst(s string) string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/strutil"
)
func main() {
strings := []string{"", "bar", "BAr", "Bar大"}
for _, v := range strings {
s := strutil.LowerFirst(v)
fmt.Println(s)
}
// Output:
//
// bar
// bAr
// bar大
}
UpperFirst
Convert the first character of string to upper case.
Signature:
func UpperFirst(s string) string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/strutil"
)
func main() {
strings := []string{"", "bar", "BAr", "bar大"}
for _, v := range strings {
s := strutil.UpperFirst(v)
fmt.Println(s)
}
// Output:
//
// Bar
// BAr
// Bar大
}
PadEnd
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/duke-git/lancet/v2/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
}
PadStart
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/duke-git/lancet/v2/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
}
Reverse
Return string whose char order is reversed to the given string.
Signature:
func Reverse(s string) string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/strutil"
)
func main() {
s := "foo"
rs := strutil.Reverse(s)
fmt.Println(s)
fmt.Println(rs)
// Output:
// foo
// oof
}
SnakeCase
Coverts string to snake_case, non letters and numbers will be ignored.
Signature:
func SnakeCase(s string) string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/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
}
UpperSnakeCase
Coverts string to upper KEBAB-CASE, non letters and numbers will be ignored.
Signature:
func SnakeCase(s string) string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/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
}
SplitEx
Split a given string whether the result contains empty string.
Signature:
func SplitEx(s, sep string, removeEmptyString bool) []string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/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 ]
}
Substring
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/duke-git/lancet/v2/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
Wrap a string with given string.
Signature:
func Wrap(str string, wrapWith string) string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/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''
//
}
Wrap
Unwrap a given string from anther string. will change source string.
Signature:
func Unwrap(str string, wrapToken string) string
Example:
import (
"fmt"
"github.com/duke-git/lancet/v2/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*
}