git/lancet

Fork 0

mirror of https://github.com/duke-git/lancet.git synced 2026-02-04 12:52:28 +08:00

Files

dudaodong 01a3b139c0 doc: add document for new functions in slice and strutil package

2023-04-18 15:49:09 +08:00

20 KiB

Raw Blame History

Strutil

strutil 包含处理字符串的相关函数。

源码:

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

用法:

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

Documentation 文档

After

返回源字符串中特定字符串首次出现时的位置之后的子字符串。

函数签名:

func After(s, char string) string

示例:

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

返回源字符串中指定字符串最后一次出现时的位置之后的子字符串。

函数签名:

func AfterLast(s, char string) string

示例:

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

返回源字符串中指定字符串第一次出现时的位置之前的子字符串。

函数签名:

func Before(s, char string) string

示例:

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

返回源字符串中指定字符串最后一次出现时的位置之前的子字符串。

函数签名:

func BeforeLast(s, char string) string

示例:

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

将字符串转换为驼峰式字符串, 非字母和数字会被忽略。

函数签名:

func CamelCase(s string) string

示例:

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

将字符串转换为kebab-case, 非字母和数字会被忽略。

函数签名:

func KebabCase(s string) string

示例:

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

将字符串转换为大写KEBAB-CASE, 非字母和数字会被忽略。

函数签名:

func UpperKebabCase(s string) string

示例:

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

将字符串的第一个字符转换为大写。

函数签名:

func Capitalize(s string) string

示例:

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

判断传入参数的数据类型是否为字符串。

函数签名:

func IsString(v any) bool

示例:

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

将字符串的第一个字符转换为小写。

函数签名:

func LowerFirst(s string) string

示例:

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

将字符串的第一个字符转换为大写形式。

函数签名:

func UpperFirst(s string) string

示例:

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

Pad

如果字符串长度短于size，则在左右两侧填充字符串。

函数签名:

func Pad(source string, size int, padStr string) string

示例:

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

如果字符串长度短于size，则在右侧填充字符串。

函数签名:

func PadEnd(source string, size int, padStr string) string

示例:

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

如果字符串长度短于size，则在左侧填充字符串。

函数签名:

func PadStart(source string, size int, padStr string) string

示例:

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

返回字符顺序与给定字符串相反的字符串。

函数签名:

func Reverse(s string) string

示例:

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

将字符串转换为snake_case形式, 非字母和数字会被忽略。

函数签名:

func SnakeCase(s string) string

示例:

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

将字符串转换为大写SNAKE_CASE形式, 非字母和数字会被忽略。

函数签名:

func SnakeCase(s string) string

示例:

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

分割字符串为切片，removeEmptyString参数指定是否去除空字符串。

函数签名:

func SplitEx(s, sep string, removeEmptyString bool) []string

示例:

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

根据指定的位置和长度截取字符串。

函数签名:

func Substring(s string, offset int, length uint) string

示例:

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

用另一个字符串包裹一个字符串。

函数签名:

func Wrap(str string, wrapWith string) string

示例:

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

用另一个字符串解开包裹一个字符串。

函数签名:

func Unwrap(str string, wrapToken string) string

示例:

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

SplitWords

将字符串拆分为单词，只支持字母字符单词。

函数签名:

func SplitWords(s string) []string

示例:

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

返回有意义单词的数量，只支持字母字符单词。

函数签名:

func WordCount(s string) int

示例:

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

RemoveNonPrintable

删除字符串中不可打印的字符。

函数签名:

func RemoveNonPrintable(str string) string

示例:

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

func main() {
    result1 := strutil.RemoveNonPrintable("hello\u00a0 \u200bworld\n")
    result2 := strutil.RemoveNonPrintable("你好😄")

    fmt.Println(result1)
    fmt.Println(result2)
    // Output:
    // hello world
    // 你好😄
}

StringToBytes

在不分配内存的情况下将字符串转换为字节片。

函数签名:

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

示例:

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

在不分配内存的情况下将字节切片转换为字符串。

函数签名:

func BytesToString(bytes []byte) string

示例:

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

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

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

IsBlank

检查字符串是否为空格或空。

函数签名:

func IsBlank(str string) bool

示例:

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

检查字符串是否以指定字符串数组中的任何一个开头。

函数签名:

func HasPrefixAny(str string, prefixes []string) bool

示例:

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

检查字符串是否以指定字符串数组中的任何一个结尾。

函数签名:

func HasSuffixAny(str string, suffixes []string) bool

示例:

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

将字符串偏移idxFrom后，返回字符串中第一个 substr 实例的索引，如果字符串中不存在 substr，则返回 -1。

函数签名:

func IndexOffset(str string, substr string, idxFrom int) int

示例:

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

20 KiB Raw Blame History Unescape Escape

Strutil

源码:

用法:

目录

Documentation 文档

After

AfterLast

Before

BeforeLast

CamelCase

KebabCase

UpperKebabCase

Capitalize

IsString

LowerFirst

UpperFirst

Pad

PadEnd

PadStart

Reverse

SnakeCase

UpperSnakeCase

SplitEx

Substring

Wrap

Wrap

SplitWords

WordCount

RemoveNonPrintable

StringToBytes

BytesToString

IsBlank

HasPrefixAny

HasSuffixAny

IndexOffset

20 KiB

Raw Blame History