git/lancet

Fork 0

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

Files

dudaodong 928e3a390d feat: merge some new functions from rc branch

2024-03-04 16:36:20 +08:00

25 KiB

Raw Blame History

Strutil

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

源码:

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

用法:

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

After
AfterLast
Before
BeforeLast
CamelCase
ContainsAll
ContainsAny
Capitalize
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
RemoveWhiteSpace
SubInBetween
HammingDistance

Documentation 文档

After

截取源字符串中char首次出现时的位置之后的子字符串

函数签名:

func After(s, char string) string

例子:

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

截取源字符串中char最后一次出现时的位置之后的子字符串

函数签名:

func AfterLast(s, char string) string

例子:

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

Before

截取源字符串中char首次出现时的位置之前的子字符串

函数签名:

func Before(s, char string) string

例子:

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

截取源字符串中char最后一次出现时的位置之前的子字符串

函数签名:

func BeforeLast(s, char string) string

例子:

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

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

函数签名:

func CamelCase(s string) string

例子:

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

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

函数签名:

func Capitalize(s string) string

例子:

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

检查值的数据类型是否为字符串

函数签名:

func IsString(v interface{}) bool

例子:

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

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

函数签名:

func KebabCase(s string) string

例子:

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

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

函数签名:

func KebabCase(s string) string

例子:

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

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

函数签名:

func LowerFirst(s string) string

例子:

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

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

函数签名:

func UpperFirst(s string) string

例子:

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

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

函数签名:

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

示例:

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

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

函数签名:

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

示例:

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

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

函数签名:

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

示例:

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

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

函数签名:

func ReverseStr(s string) string

例子:

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

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

函数签名:

func SnakeCase(s string) string

例子:

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

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

函数签名:

func SnakeCase(s string) string

例子:

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

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

函数签名:

func Wrap(str string, wrapWith string) string

例子:

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

Unwrap

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

函数签名:

func Unwrap(str string, wrapToken string) string

例子:

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

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

函数签名:

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

例子:

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

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

函数签名:

func SplitWords(s string) []string

示例:

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

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

函数签名:

func WordCount(s string) int

示例:

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
}

RemoveNonPrintable

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

函数签名:

func RemoveNonPrintable(str string) string

示例:

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

返回`str`的副本，以无序的方式被map替换，区分大小写。

函数签名:

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

示例:

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

从字符串的开头和结尾去除空格（或其他字符）。可选参数 characterMask 指定额外的剥离字符。

函数签名:

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

示例:

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

将字符串str按字符串delimiter拆分为一个切片，并对该数组的每个元素调用Trim。忽略Trim后为空的元素。

函数签名:

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

示例:

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

使用参数`replaceChar`隐藏源字符串中的一些字符。替换范围是 origin[start : end]。

函数签名:

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

示例:

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

判断字符串是否包括全部给定的子字符串切片。

函数签名:

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

示例:

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

判断字符串是否包括给定的子字符串切片中任意一个子字符串。

函数签名:

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

示例:

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
}

RemoveWhiteSpace

删除字符串中的空格，当设置repalceAll为true时，删除全部空格，为false时，替换多个空格为1个空格。

函数签名:

func RemoveWhiteSpace(str string, repalceAll bool) string

示例:

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

func main() {
    str := " hello   \r\n   \t   world"

    result1 := strutil.RemoveWhiteSpace(str, true)
    result2 := strutil.RemoveWhiteSpace(str, false)

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

    // Output:
    // helloworld
    // hello world
}

SubInBetween

获取字符串中指定的起始字符串start和终止字符串end直接的子字符串。

函数签名:

func SubInBetween(str string, start string, end string) string

示例:

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

func main() {
    str := "abcde"

    result1 := strutil.SubInBetween(str, "", "de")
    result2 := strutil.SubInBetween(str, "a", "d")

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

    // Output:
    // abc
    // bc
}

HammingDistance

计算两个字符串之间的汉明距离。汉明距离是指对应符号不同的位置数。

函数签名:

HammingDistance(a, b string) (int, error)

示例:

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

func main() {

    result1, _ := strutil.HammingDistance("de", "de")
    result2, _ := strutil.HammingDistance("a", "d")

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

    // Output:
    // 0
    // 1
}

25 KiB Raw Blame History Unescape Escape

Strutil

源码:

用法:

目录

Documentation 文档

After

AfterLast

Before

BeforeLast

CamelCase

Capitalize

IsString

KebabCase

UpperKebabCase

LowerFirst

UpperFirst

Pad

PadEnd

PadStart

ReverseStr

SnakeCase

UpperSnakeCase

Wrap

Unwrap

SplitEx

SplitWords

WordCount

RemoveNonPrintable

StringToBytes

BytesToString

IsBlank

HasPrefixAny

HasSuffixAny

IndexOffset

ReplaceWithMap

Trim

SplitAndTrim

HideString

ContainsAll

ContainsAny

RemoveWhiteSpace

SubInBetween

HammingDistance

25 KiB

Raw Blame History