git/lancet

Fork 0

mirror of https://github.com/duke-git/lancet.git synced 2026-02-04 21:02:27 +08:00

Files

dudaodong 4b8b624b4c feat: add ContainsAll and ContainsAny

2023-05-31 17:27:25 +08:00

22 KiB

Raw Blame History

Strutil

Package strutil contains some functions to manipulate string.

Source:

https://github.com/duke-git/lancet/blob/v1/strutil/string.go

Usage:

import (
    "github.com/duke-git/lancet/strutil"
)

Index

After
AfterLast
Before
BeforeLast
CamelCase
Capitalize
ContainsAll
ContainsAny
IsString
KebabCase
UpperKebabCase
LowerFirst
UpperFirst
Pad
PadEnd
PadStart
Reverse
SnakeCase
UpperSnakeCase
Wrap
Unwrap
SplitEx
SplitWords
WordCount
RemoveNonPrintable
StringToBytes
BytesToString
IsBlank
HasPrefixAny
HasSuffixAny
IndexOffset
ReplaceWithMap
Trim
SplitAndTrim
HideString

Documentation

After

Creates substring in source string after position when char first appear.

Signature:

func After(s, char string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    s1 := strutil.After("lancet", "")
    fmt.Println(s1) //lancet

    s2 := strutil.After("github.com/test/lancet", "/")
    fmt.Println(s2) //test/lancet

    s3 := strutil.After("github.com/test/lancet", "test")
    fmt.Println(s3) // /lancet
}

AfterLast

Creates substring in source string after position when char last appear.

Signature:

func AfterLast(s, char string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    s1 := strutil.AfterLast("lancet", "")
    fmt.Println(s1) //lancet

    s2 := strutil.AfterLast("github.com/test/lancet", "/")
    fmt.Println(s2) //lancet

    s3 := strutil.AfterLast("github.com/test/test/lancet", "test")
    fmt.Println(s3) // /test/lancet
}

Before

Creates substring in source string before position when char first appear.

Signature:

func Before(s, char string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    s1 := strutil.Before("lancet", "")
    fmt.Println(s1) //lancet

    s2 := strutil.Before("github.com/test/lancet", "/")
    fmt.Println(s2) //github.com

    s3 := strutil.Before("github.com/test/lancet", "test")
    fmt.Println(s3) // github.com/
}

BeforeLast

Creates substring in source string before position when char first appear.

Signature:

func BeforeLast(s, char string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    s1 := strutil.BeforeLast("lancet", "")
    fmt.Println(s1) //lancet

    s2 := strutil.BeforeLast("github.com/test/lancet", "/")
    fmt.Println(s2) //github.com/test

    s3 := strutil.BeforeLast("github.com/test/test/lancet", "test")
    fmt.Println(s3) //github.com/test/
}

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/strutil"
)

func main() {
    s1 := strutil.CamelCase("foo_bar")
    fmt.Println(s1) //fooBar

    s2 := strutil.CamelCase("Foo-Bar")
    fmt.Println(s2) //fooBar

    s3 := strutil.CamelCase("Foo&bar")
    fmt.Println(s3) //fooBar

    s4 := strutil.CamelCase("foo bar")
    fmt.Println(s4) //fooBar

    s4 := strutil.CamelCase("Foo-#1😄$_%^&*(1bar")
    fmt.Println(s4) //foo11Bar

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/strutil"
)

func main() {
    s1 := strutil.Capitalize("foo")
    fmt.Println(s1) //foo

    s2 := strutil.Capitalize("Foo")
    fmt.Println(s2) //foo

    s3 := strutil.Capitalize("FOo"
    fmt.Println(s3) //fOo
}

IsString

Check if the value's data type is string.

Signature:

func IsString(v interface{}) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    fmt.Println(strutil.IsString("lancet")) //true
    fmt.Println(strutil.IsString("")) //true

    fmt.Println(strutil.IsString(1)) //false
    fmt.Println(strutil.IsString("")) //false
    fmt.Println(strutil.IsString([]string{})) //false
}

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/strutil"
)

func main() {
    s1 := strutil.KebabCase("Foo Bar-")
    fmt.Println(s1) //foo-bar

    s2 := strutil.KebabCase("foo_Bar")
    fmt.Println(s2) //foo-bar

    s3 := strutil.KebabCase("fooBar")
    fmt.Println(s3) //foo-bar

    s4 := strutil.KebabCase("__FOO_BAR__")
    fmt.Println(s4) //foo-bar
}

UpperKebabCase

UpperKebabCase covert string to upper KEBAB-CASE, non letters and numbers will be ignored.

Signature:

func KebabCase(s string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    s1 := strutil.UpperKebabCase("Foo Bar-")
    fmt.Println(s1) //FOO-BAR

    s2 := strutil.UpperKebabCase("foo_Bar")
    fmt.Println(s2) //FOO-BAR

    s3 := strutil.UpperKebabCase("fooBar")
    fmt.Println(s3) //FOO-BAR

    s4 := strutil.UpperKebabCase("__FOO_BAR__")
    fmt.Println(s4) //FOO-BAR
}

LowerFirst

Convert the first character of string to lower case.

Signature:

func LowerFirst(s string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    s1 := strutil.LowerFirst("foo")
    fmt.Println(s1) //foo

    s2 := strutil.LowerFirst("BAR")
    fmt.Println(s2) //bAR

    s3 := strutil.LowerFirst("FOo")
    fmt.Println(s3) //fOo

    s4 := strutil.LowerFirst("fOo大")
    fmt.Println(s4) //fOo大
}

UpperFirst

Convert the first character of string to upper case.

Signature:

func UpperFirst(s string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    s1 := strutil.UpperFirst("foo")
    fmt.Println(s1) //Foo

    s2 := strutil.UpperFirst("bAR")
    fmt.Println(s2) //BAR

    s3 := strutil.UpperFirst("FOo")
    fmt.Println(s3) //FOo

    s4 := strutil.UpperFirst("fOo大")
    fmt.Println(s4) //FOo大
}

Pad

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/duke-git/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
}

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/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/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
}

ReverseStr

Return string whose char order is reversed to the given string.

Signature:

func ReverseStr(s string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    s1 := strutil.ReverseStr("abc")
    fmt.Println(s1) //cba

    s2 := strutil.ReverseStr("12345")
    fmt.Println(s2) //54321
}

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/strutil"
)

func main() {
    s1 := strutil.SnakeCase("Foo Bar-")
    fmt.Println(s1) //foo_bar

    s2 := strutil.SnakeCase("foo_Bar")
    fmt.Println(s2) //foo_bar

    s3 := strutil.SnakeCase("fooBar")
    fmt.Println(s3) //foo_bar

    s4 := strutil.SnakeCase("__FOO_BAR__")
    fmt.Println(s4) //foo_bar

    s5 := strutil.SnakeCase("Foo-#1😄$_%^&*(1bar")
    fmt.Println(s5) //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/strutil"
)

func main() {
    s1 := strutil.UpperSnakeCase("Foo Bar-")
    fmt.Println(s1) //FOO_BAR

    s2 := strutil.UpperSnakeCase("foo_Bar")
    fmt.Println(s2) //FOO_BAR

    s3 := strutil.UpperSnakeCase("fooBar")
    fmt.Println(s3) //FOO_BAR

    s4 := strutil.UpperSnakeCase("__FOO_BAR__")
    fmt.Println(s4) //FOO_BAR

    s5 := strutil.UpperSnakeCase("Foo-#1😄$_%^&*(1bar")
    fmt.Println(s5) //FOO_1_1_BAR
}

Wrap

Wrap a string with another string.

Signature:

func Wrap(str string, wrapWith string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    s1 := strutil.Wrap("ab", "")
    fmt.Println(s1) //ab

    s2 := strutil.Wrap("", "*")
    fmt.Println(s2) //""

    s3 := strutil.Wrap("ab", "*")
    fmt.Println(s3) //*ab*

    s4 := strutil.Wrap("ab", "\"")
    fmt.Println(s4) //\"ab\"

    s5 := strutil.Wrap("ab", "'")
    fmt.Println(s5) //'ab'
}

Wrap

Unwrap a given string from anther string. will change str value.

Signature:

func Unwrap(str string, wrapToken string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    s1 := strutil.Unwrap("ab", "")
    fmt.Println(s1) //ab

    s2 := strutil.Unwrap("ab", "*")
    fmt.Println(s2) //ab

    s3 := strutil.Unwrap("**ab**", "*")
    fmt.Println(s3) //*ab*

    s4 := strutil.Unwrap("*ab", "*")
    fmt.Println(s4) //*ab

    s5 := strutil.Unwrap("***", "**")
    fmt.Println(s5) //***
}

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/strutil"
)

func main() {
    arr1 := strutil.SplitEx(" a b c ", "", true)
    fmt.Println(arr1) //[]string{}

    arr2 := strutil.SplitEx(" a b c ", " ", false)
    fmt.Println(arr2) //[]string{"", "a", "b", "c", ""}

    arr3 := strutil.SplitEx(" a b c ", " ", true)
    fmt.Println(arr3) //[]string{"a", "b", "c"}

    arr4 := strutil.SplitEx(" a = b = c = ", " = ", false)
    fmt.Println(arr4) //[]string{" a", "b", "c", ""}

    arr5 := strutil.SplitEx(" a = b = c = ", " = ", true)
    fmt.Println(arr5) //[]string{" a", "b", "c"}
}

SplitWords

Splits a string into words, word only contains alphabetic characters.

Signature:

func SplitWords(s string) []string

Example:

import (
    "fmt"
    "github.com/duke-git/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]
    // []
    // []
}

WordCount

Return the number of meaningful word, word only contains alphabetic characters.

Signature:

func WordCount(s string) int

Example:

import (
    "fmt"
    "github.com/duke-git/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
}

StringToBytes

Converts a string to byte slice without a memory allocation.

Signature:

func StringToBytes(str string) (b []byte)

Example:

import (
    "fmt"
    "github.com/duke-git/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
}

BytesToString

Converts a byte slice to string without a memory allocation.

Signature:

func BytesToString(bytes []byte) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    bytes := []byte{'a', 'b', 'c'}
	result := strutil.BytesToString(bytes)

	fmt.Println(result)
	// Output:
	// abc
}

IsBlank

Checks if a string is whitespace or empty.

Signature:

func IsBlank(str string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/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
}

HasPrefixAny

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/duke-git/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
}

HasSuffixAny

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/duke-git/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
}

IndexOffset

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/duke-git/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
}

ReplaceWithMap

Returns a copy of `str`, which is replaced by a map in unordered way, case-sensitively.

Signature:

func ReplaceWithMap(str string, replaces map[string]string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    str := "ac ab ab ac"
	replaces := map[string]string{
		"a": "1",
		"b": "2",
	}

	result := strutil.ReplaceWithMap(str, replaces)

	fmt.Println(result)
	// Output:
	// 1c 12 12 1c
}

Trim

Strips whitespace (or other characters) from the beginning and end of a string. The optional parameter `characterMask` specifies the additional stripped characters.

Signature:

func Trim(str string, characterMask ...string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    result1 := strutil.Trim("\nabcd")

	str := "$ ab	cd $ "

	result2 := strutil.Trim(str)
	result3 := strutil.Trim(str, "$")

	fmt.Println(result1)
	fmt.Println(result2)
	fmt.Println(result3)

	// Output:
	// abcd
	// $ ab	cd $
	// ab	cd
}

SplitAndTrim

Splits string `str` by a string `delimiter` to a slice, and calls Trim to every element of slice. It ignores the elements which are empty after Trim.

Signature:

func SplitAndTrim(str, delimiter string, characterMask ...string) []string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    str := " a,b, c,d,$1 "

	result1 := strutil.SplitAndTrim(str, ",")
	result2 := strutil.SplitAndTrim(str, ",", "$")

	fmt.Println(result1)
	fmt.Println(result2)

	// Output:
	// [a b c d $1]
	// [a b c d 1]
}

HideString

HideString hide some chars in source string with param `replaceChar`. replace range is origin[start : end]. [start, end).

Signature:

func HideString(origin string, start, end int, replaceChar string) string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    str := "13242658976"

	result1 := strutil.HideString(str, 3, 3, "*")
	result2 := strutil.HideString(str, 3, 4, "*")
	result3 := strutil.HideString(str, 3, 7, "*")
	result4 := strutil.HideString(str, 7, 11, "*")

	fmt.Println(result1)
	fmt.Println(result2)
	fmt.Println(result3)
	fmt.Println(result4)

	// Output:
	// 13242658976
	// 132*2658976
	// 132****8976
	// 1324265****
}

ContainsAll

Return true if target string contains all the substrings.

Signature:

func ContainsAll(str string, substrs []string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    str := "hello world"

    result1 := strutil.ContainsAll(str, []string{"hello", "world"})
    result2 := strutil.ContainsAll(str, []string{"hello", "abc"})

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}

ContainsAny

Return true if target string contains any one of the substrings.

Signature:

func ContainsAny(str string, substrs []string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/strutil"
)

func main() {
    str := "hello world"

    result1 := strutil.ContainsAny(str, []string{"hello", "world"})
    result2 := strutil.ContainsAny(str, []string{"hello", "abc"})
    result3 := strutil.ContainsAny(str, []string{"123", "abc"})

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)

    // Output:
    // true
    // true
    // false
}

22 KiB Raw Blame History

Strutil

Source:

Usage:

Index

Documentation

After

AfterLast

Before

BeforeLast

CamelCase

Capitalize

IsString

KebabCase

UpperKebabCase

LowerFirst

UpperFirst

Pad

PadEnd

PadStart

ReverseStr

SnakeCase

UpperSnakeCase

Wrap

Wrap

SplitEx

SplitWords

WordCount

StringToBytes

BytesToString

IsBlank

HasPrefixAny

HasSuffixAny

IndexOffset

ReplaceWithMap

Trim

SplitAndTrim

HideString

ContainsAll

ContainsAny

22 KiB

Raw Blame History