创建元素为指定值的stream。
+ +函数签名: + +```go +func Of[T any](elems ...T) stream[T] +``` + +示例:[运行](https://go.dev/play/p/jI6_iZZuVFE) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s := stream.Of(1, 2, 3) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3] +} +``` + +### FromSlice + +从切片创建stream。
+ +函数签名: + +```go +func FromSlice[T any](source []T) stream[T] +``` + +示例:[运行](https://go.dev/play/p/wywTO0XZtI4) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s := stream.FromSlice([]int{1, 2, 3}) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3] +} +``` + +### FromChannel + +从通道创建stream。
+ +函数签名: + +```go +func FromChannel[T any](source <-chan T) stream[T] +``` + +示例:[运行](https://go.dev/play/p/9TZYugGMhXZ) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + ch := make(chan int) + go func() { + for i := 1; i < 4; i++ { + ch <- i + } + close(ch) + }() + + s := stream.FromChannel(ch) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3] +} +``` + +### FromRange + +指定一个范围创建stream, 范围两端点值都包括在内。
+ +函数签名: + +```go +func FromRange[T constraints.Integer | constraints.Float](start, end, step T) stream[T] +``` + +示例:[运行](https://go.dev/play/p/9Ex1-zcg-B-) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s := stream.FromRange(1, 5, 1) + + data := s.ToSlice() + fmt.Println(data) + + // Output: + // [1 2 3 4 5] +} +``` + +### Generate + +创建一个stream，其中每个元素都由提供的生成器函数生成
+ +函数签名: + +```go +func Generate[T any](generator func() func() (item T, ok bool)) stream[T] +``` + +示例:[运行](https://go.dev/play/p/rkOWL1yA3j9) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + n := 0 + max := 4 + + generator := func() func() (int, bool) { + return func() (int, bool) { + n++ + return n, n < max + } + } + + s := stream.Generate(generator) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3] +} +``` + +### Concat + +创建一个延迟连接stream，其元素是第一个stream的所有元素，后跟第二个stream的全部元素。
+ +函数签名: + +```go +func Concat[T any](a, b stream[T]) stream[T] +``` + +示例:[运行](https://go.dev/play/p/HM4OlYk_OUC) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s1 := stream.FromSlice([]int{1, 2, 3}) + s2 := stream.FromSlice([]int{4, 5, 6}) + + s := Concat(s1, s2) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3 4 5 6] +} +``` + +### Distinct + +创建并返回一个stream，用于删除重复的项。 支持链式操作
+ +函数签名: + +```go +func (s stream[T]) Distinct() stream[T] +``` + +示例:[运行](https://go.dev/play/p/eGkOSrm64cB) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 2, 3, 3, 3}) + distinct := original.Distinct() + + data1 := original.ToSlice() + data2 := distinct.ToSlice() + + fmt.Println(data1) + fmt.Println(data2) + + // Output: + // [1 2 2 3 3 3] + // [1 2 3] +} +``` + +### Filter + +返回一个通过判定函数的stream 支持链式操作
+ +函数签名: + +```go +func (s stream[T]) Filter(predicate func(item T) bool) stream[T] +``` + +示例:[运行](https://go.dev/play/p/MFlSANo-buc) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3, 4, 5}) + + isEven := func(n int) bool { + return n%2 == 0 + } + + even := original.Filter(isEven) + + fmt.Println(even.ToSlice()) + + // Output: + // [2 4] +} +``` + +### Map + +返回一个stream，该stream由将给定函数应用于源stream元素的元素组成。支持链式操作
+ +函数签名: + +```go +func (s stream[T]) Map(mapper func(item T) T) stream[T] +``` + +示例:[运行](https://go.dev/play/p/OtNQUImdYko) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + addOne := func(n int) int { + return n + 1 + } + + increament := original.Map(addOne) + + fmt.Println(increament.ToSlice()) + + // Output: + // [2 3 4] +} +``` + +### Peek + +返回一个由源stream的元素组成的stream，并在从生成的stream中消耗元素时对每个元素执行所提供的操作。 支持链式操作
+ +函数签名: + +```go +func (s stream[T]) Peek(consumer func(item T)) stream[T] +``` + +示例:[运行](https://go.dev/play/p/u1VNzHs6cb2) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + data := []string{} + peekStream := original.Peek(func(n int) { + data = append(data, fmt.Sprint("value", n)) + }) + + fmt.Println(original.ToSlice()) + fmt.Println(peekStream.ToSlice()) + fmt.Println(data) + + // Output: + // [1 2 3] + // [1 2 3] + // [value1 value2 value3] +} +``` + +### Skip + +在丢弃stream的前n个元素后，返回由源stream的其余元素组成的stream。如果此stream包含的元素少于n个，则将返回一个空stream。支持链式操作
+ +函数签名: + +```go +func (s stream[T]) Skip(n int) stream[T] +``` + +示例:[运行](https://go.dev/play/p/fNdHbqjahum) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3, 4}) + + s1 := original.Skip(-1) + s2 := original.Skip(0) + s3 := original.Skip(1) + s4 := original.Skip(5) + + fmt.Println(s1.ToSlice()) + fmt.Println(s2.ToSlice()) + fmt.Println(s3.ToSlice()) + fmt.Println(s4.ToSlice()) + + // Output: + // [1 2 3 4] + // [1 2 3 4] + // [2 3 4] + // [] +} +``` + +### Limit + +返回由源stream的元素组成的stream，该stream被截断为长度不超过maxSize。支持链式操作
+ +函数签名: + +```go +func (s stream[T]) Limit(maxSize int) stream[T] +``` + +示例:[运行](https://go.dev/play/p/qsO4aniDcGf) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3, 4}) + + s1 := original.Limit(-1) + s2 := original.Limit(0) + s3 := original.Limit(1) + s4 := original.Limit(5) + + fmt.Println(s1.ToSlice()) + fmt.Println(s2.ToSlice()) + fmt.Println(s3.ToSlice()) + fmt.Println(s4.ToSlice()) + + // Output: + // [] + // [] + // [1] + // [1 2 3 4] +} +``` + +### Reverse + +返回元素与源stream的顺序相反的stream。支持链式操作
+ +函数签名: + +```go +func (s stream[T]) Reverse() stream[T] +``` + +示例:[运行](https://go.dev/play/p/A8_zkJnLHm4) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + reverse := original.Reverse() + + fmt.Println(reverse.ToSlice()) + + // Output: + // [3 2 1] +} +``` + +### Range + +返回一个stream，该stream的元素在从源stream的开始（包含）到结束（排除）的范围内。支持链式操作
+ +函数签名: + +```go +func (s stream[T]) Range(start, end int) stream[T] +``` + +示例:[运行](https://go.dev/play/p/indZY5V2f4j) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + s1 := original.Range(0, 0) + s2 := original.Range(0, 1) + s3 := original.Range(0, 3) + s4 := original.Range(1, 2) + + fmt.Println(s1.ToSlice()) + fmt.Println(s2.ToSlice()) + fmt.Println(s3.ToSlice()) + fmt.Println(s4.ToSlice()) + + // Output: + // [] + // [1] + // [1 2 3] + // [2] +} +``` + +### Sorted + +返回一个stream，该stream由源stream的元素组成，并根据提供的less函数进行排序。支持链式操作
+ +函数签名: + +```go +func (s stream[T]) Sorted(less func(a, b T) bool) stream[T] +``` + +示例:[运行](https://go.dev/play/p/XXtng5uonFj) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{4, 2, 1, 3}) + + sorted := original.Sorted(func(a, b int) bool { return a < b }) + + fmt.Println(original.ToSlice()) + fmt.Println(sorted.ToSlice()) + + // Output: + // [4 2 1 3] + // [1 2 3 4] +} +``` + +### ForEach + +对stream的每个元素执行一个操作。
+ +函数签名: + +```go +func (s stream[T]) ForEach(action func(item T)) +``` + +示例:[运行](https://go.dev/play/p/Dsm0fPqcidk) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result := 0 + original.ForEach(func(item int) { + result += item + }) + + fmt.Println(result) + + // Output: + // 6 +} +``` + +### Reduce + +使用关联累加函数对stream的元素执行reduce操作，并reduce操作结果（如果有）。
+ +函数签名: + +```go +func (s stream[T]) Reduce(initial T, accumulator func(a, b T) T) T +``` + +示例:[运行](https://go.dev/play/p/6uzZjq_DJLU) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result := original.Reduce(0, func(a, b int) int { + return a + b + }) + + fmt.Println(result) + + // Output: + // 6 +} +``` + +### FindFirst + +返回此stream的第一个元素和true，如果stream为空，则返回零值和false。
+ +函数签名: + +```go +func (s stream[T]) FindFirst() (T, bool) +``` + +示例:[运行](https://go.dev/play/p/9xEf0-6C1e3) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result, ok := original.FindFirst() + + fmt.Println(result) + fmt.Println(ok) + + // Output: + // 1 + // true +} +``` + +### FindLast + +返回此stream最后一个元素和true，如果stream为空，则返回零值和false。
+ +函数签名: + +```go +func (s stream[T]) FindLast() (T, bool) +``` + +示例:[运行](https://go.dev/play/p/WZD2rDAW-2h) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{3, 2, 1}) + + result, ok := original.FindLast() + + fmt.Println(result) + fmt.Println(ok) + + // Output: + // 1 + // true +} +``` + +### Max + +根据提供的less函数返回stream的最大元素。less 函数: a > b
+ +函数签名: + +```go +func (s stream[T]) Max(less func(a, b T) bool) (T, bool) +``` + +示例:[运行](https://go.dev/play/p/fm-1KOPtGzn) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{4, 2, 1, 3}) + + max, ok := original.Max(func(a, b int) bool { return a > b }) + + fmt.Println(max) + fmt.Println(ok) + + // Output: + // 4 + // true +} +``` + +### Min + +根据提供的less函数返回stream的最小元素。less函数: a < b
+ +函数签名: + +```go +func (s stream[T]) Min(less func(a, b T) bool) (T, bool) +``` + +示例:[运行](https://go.dev/play/p/vZfIDgGNRe_0) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{4, 2, 1, 3}) + + min, ok := original.Min(func(a, b int) bool { return a < b }) + + fmt.Println(min) + fmt.Println(ok) + + // Output: + // 1 + // true +} +``` + +### AllMatch + +判断stream的所有元素是否全部匹配指定判定函数。
+ +函数签名: + +```go +func (s stream[T]) AllMatch(predicate func(item T) bool) bool +``` + +示例:[运行](https://go.dev/play/p/V5TBpVRs-Cx) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result1 := original.AllMatch(func(item int) bool { + return item > 0 + }) + + result2 := original.AllMatch(func(item int) bool { + return item > 1 + }) + + fmt.Println(result1) + fmt.Println(result2) + + // Output: + // true + // false +} +``` + +### AnyMatch + +判断stream是否包含匹配指定判定函数的元素。
+ +函数签名: + +```go +func (s stream[T]) AnyMatch(predicate func(item T) bool) bool +``` + +示例:[运行](https://go.dev/play/p/PTCnWn4OxSn) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result1 := original.AnyMatch(func(item int) bool { + return item > 1 + }) + + result2 := original.AnyMatch(func(item int) bool { + return item > 3 + }) + + fmt.Println(result1) + fmt.Println(result2) + + // Output: + // true + // false +} +``` + +### NoneMatch + +判断stream的元素是否全部不匹配指定的判定函数。
+ +函数签名: + +```go +func (s stream[T]) NoneMatch(predicate func(item T) bool) bool +``` + +示例:[运行](https://go.dev/play/p/iWS64pL1oo3) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result1 := original.NoneMatch(func(item int) bool { + return item > 3 + }) + + result2 := original.NoneMatch(func(item int) bool { + return item > 1 + }) + + fmt.Println(result1) + fmt.Println(result2) + + // Output: + // true + // false +} +``` + +### Count + +返回stream中元素的数量。
+ +函数签名: + +```go +func (s stream[T]) Count() int +``` + +示例:[运行](https://go.dev/play/p/r3koY6y_Xo-) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s1 := stream.FromSlice([]int{1, 2, 3}) + s2 := stream.FromSlice([]int{}) + + fmt.Println(s1.Count()) + fmt.Println(s2.Count()) + + // Output: + // 3 + // 0 +} +``` + +### ToSlice + +返回stream中的元素切片。
+ +函数签名: + +```go +func (s stream[T]) ToSlice() []T +``` + +示例:[运行](https://go.dev/play/p/jI6_iZZuVFE) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s := stream.Of(1, 2, 3) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3] +} +``` diff --git a/docs/api/packages/struct.md b/docs/api/packages/struct.md new file mode 100644 index 0000000..dd8d10b --- /dev/null +++ b/docs/api/packages/struct.md @@ -0,0 +1,534 @@ +# Structs + +structs 包封装了一个抽象的`Struct`结构体，提供了操作`struct`的相关函数 + + + +## 源码: + +- [https://github.com/duke-git/lancet/blob/main/structs/struct.go](https://github.com/duke-git/lancet/blob/main/structs/struct.go) + +- [https://github.com/duke-git/lancet/blob/main/structs/field.go](https://github.com/duke-git/lancet/blob/main/structs/field.go) + + + +## 用法: + +```go +import ( + "github.com/duke-git/lancet/v2/structs" +) +``` + + + +## 目录: + +- [New](#New) +- [ToMap](#ToMap) +- [Fields](#Fields) +- [Field](#Field) +- [IsStruct](#IsStruct) +- [Tag](#Tag) +- [Name](#Name) +- [Value](#Value) +- [Kind](#Kind) +- [IsEmbedded](#IsEmbedded) +- [IsExported](#IsExported) +- [IsZero](#IsZero) +- [IsSlice](#IsSlice) + + + +## API 文档: + +### New + +`Struct`结构体的构造函数
+ +函数签名: + +```go +func New(value any, tagName ...string) *Struct +``` + +示例: + +```go +package main + +import ( + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type People struct { + Name string `json:"name"` + } + p1 := &People{Name: "11"} + s := structs.New(p1) + // to do something +} +``` + +### ToMap + +将一个合法的struct对象转换为map[string]any
+ +函数签名: + +```go +func (s *Struct) ToMap() (map[string]any, error) +``` + +除此之外，提供一个便捷的静态方法 ToMap + +```go +func ToMap(v any) (map[string]any, error) +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type People struct { + Name string `json:"name"` + } + p1 := &People{Name: "11"} + s1 := structs.New(p1) + m1, _ := s1.ToMap() + + fmt.Println(m1) + + // 如果不需要Struct更多的方法，可以直接使用ToMap + m2, _ := structs.ToMap(p1) + + fmt.Println(m2) + + // Output: + // map[name:11] + // map[name:11] +} +``` + +### Fields + +获取一个struct对象的属性列表
+ +函数签名: + +```go +func (s *Struct) Fields() []*Field +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type People struct { + Name string `json:"name"` + } + p1 := &People{Name: "11"} + s := structs.New(p1) + fields := s.Fields() + + fmt.Println(len(fields)) + + // Output: + // 1 +} +``` + +### Field + +根据属性名获取一个struct对象的属性
+ +函数签名: + +```go +func (s *Struct) Field(name string) *Field +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type People struct { + Name string `json:"name"` + } + p1 := &People{Name: "11"} + s := structs.New(p1) + f := s.Field("Name") + + fmt.Println(f.Value()) + + // Output: + // 11 +} +``` + +### IsStruct + +判断是否为一个合法的struct对象
+ +函数签名: + +```go +func (s *Struct) IsStruct() bool +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type People struct { + Name string `json:"name"` + } + p1 := &People{Name: "11"} + s := structs.New(p1) + + fmt.Println(s.IsStruct()) + + // Output: + // true +} +``` + +### Tag + +获取`Field`的`Tag`，默认的tag key是json
+ +函数签名: + +```go +func (f *Field) Tag() *Tag +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string `json:"name,omitempty"` + } + p1 := &Parent{"111"} + + s := structs.New(p1) + n, _ := s.Field("Name") + tag := n.Tag() + + fmt.Println(tag.Name) + + // Output: + // name +} +``` + +### Value + +获取`Field`属性的值
+ +函数签名: + +```go +func (f *Field) Value() any +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string `json:"name,omitempty"` + } + p1 := &Parent{"111"} + + s := structs.New(p1) + n, _ := s.Field("Name") + + fmt.Println(n.Value()) + + // Output: + // 111 +} +``` + +### IsEmbedded + +判断属性是否为嵌入
+ +函数签名: + +```go +func (f *Field) IsEmbedded() bool +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + } + type Child struct { + Parent + Age int + } + c1 := &Child{} + c1.Name = "111" + c1.Age = 11 + + s := structs.New(c1) + n, _ := s.Field("Name") + a, _ := s.Field("Age") + + fmt.Println(n.IsEmbedded()) + fmt.Println(a.IsEmbedded()) + + // Output: + // true + // false +} +``` + +### IsExported + +判断属性是否导出
+ +函数签名: + +```go +func (f *Field) IsExported() bool +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + age int + } + p1 := &Parent{Name: "11", age: 11} + s := structs.New(p1) + n, _ := s.Field("Name") + a, _ := s.Field("age") + + fmt.Println(n.IsExported()) + fmt.Println(a.IsExported()) + + // Output: + // true + // false +} +``` + +### IsZero + +判断属性是否为零值
+ +函数签名: + +```go +func (f *Field) IsZero() bool +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + Age int + } + p1 := &Parent{Age: 11} + s := structs.New(p1) + n, _ := s.Field("Name") + a, _ := s.Field("Age") + + fmt.Println(n.IsZero()) + fmt.Println(a.IsZero()) + + // Output: + // true + // false +} +``` + +### Name + +获取属性名
+ +函数签名: + +```go +func (f *Field) Name() string +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + Age int + } + p1 := &Parent{Age: 11} + s := structs.New(p1) + n, _ := s.Field("Name") + a, _ := s.Field("Age") + + fmt.Println(n.Name()) + fmt.Println(a.Name()) + + // Output: + // Name + // Age +} +``` + +### Kind + +获取属性Kind
+ +函数签名: + +```go +func (f *Field) Kind() reflect.Kind +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + Age int + } + p1 := &Parent{Age: 11} + s := structs.New(p1) + n, _ := s.Field("Name") + a, _ := s.Field("Age") + + fmt.Println(n.Kind()) + fmt.Println(a.Kind()) + + // Output: + // string + // int +} +``` + +### IsSlice + +判断属性是否是切片
+ +函数签名: + +```go +func (f *Field) IsSlice() bool +``` + +示例: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + arr []int + } + + p1 := &Parent{arr: []int{1, 2, 3}} + s := structs.New(p1) + a, _ := s.Field("arr") + + fmt.Println(a.IsSlice()) + + // Output: + // true +} +``` \ No newline at end of file diff --git a/docs/api/packages/strutil.md b/docs/api/packages/strutil.md new file mode 100644 index 0000000..fcec970 --- /dev/null +++ b/docs/api/packages/strutil.md @@ -0,0 +1,1426 @@ +# Strutil + +strutil 包含处理字符串的相关函数。 + + + +## 源码: + +- [https://github.com/duke-git/lancet/blob/main/strutil/string.go](https://github.com/duke-git/lancet/blob/main/strutil/string.go) + + + +## 用法: + +```go +import ( + "github.com/duke-git/lancet/v2/strutil" +) +``` + + + +## 目录 + +- [After](#After) +- [AfterLast](#AfterLast) +- [Before](#Before) +- [BeforeLast](#BeforeLast) +- [CamelCase](#CamelCase) +- [Capitalize](#Capitalize) +- [IsString](#IsString) +- [KebabCase](#KebabCase) +- [UpperKebabCase](#UpperKebabCase) +- [LowerFirst](#LowerFirst) +- [UpperFirst](#UpperFirst) +- [Pad](#Pad) +- [PadEnd](#PadEnd) +- [PadStart](#PadStart) +- [Reverse](#Reverse) +- [SnakeCase](#SnakeCase) +- [UpperSnakeCase](#UpperSnakeCase) +- [SplitEx](#SplitEx) +- [Substring](#Substring) +- [Wrap](#Wrap) +- [Unwrap](#Unwrap) +- [SplitWords](#SplitWords) +- [WordCount](#WordCount) +- [RemoveNonPrintable](#RemoveNonPrintable) +- [StringToBytes](#StringToBytes) +- [BytesToString](#BytesToString) +- [IsBlank](#IsBlank) +- [HasPrefixAny](#HasPrefixAny) +- [HasSuffixAny](#HasSuffixAny) +- [IndexOffset](#IndexOffset) +- [ReplaceWithMap](#ReplaceWithMap) +- [Trim](#Trim) +- [SplitAndTrim](#SplitAndTrim) +- [HideString](#HideString) +- [ContainsAll](#ContainsAll) +- [ContainsAny](#ContainsAny) +- [RemoveWhiteSpace](#RemoveWhiteSpace) + + + + + +## 文档 + +### After + +返回源字符串中特定字符串首次出现时的位置之后的子字符串。
+ +函数签名: + +```go +func After(s, char string) string +``` + +示例:[运行](https://go.dev/play/p/RbCOQqCDA7m) + +```go +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 + +返回源字符串中指定字符串最后一次出现时的位置之后的子字符串。
+ +函数签名: + +```go +func AfterLast(s, char string) string +``` + +示例:[运行](https://go.dev/play/p/1TegARrb8Yn) + +```go +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 + +返回源字符串中指定字符串第一次出现时的位置之前的子字符串。
+ +函数签名: + +```go +func Before(s, char string) string +``` + +示例:[运行](https://go.dev/play/p/JAWTZDS4F5w) + +```go +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 + +返回源字符串中指定字符串最后一次出现时的位置之前的子字符串。
+ +函数签名: + +```go +func BeforeLast(s, char string) string +``` + +示例:[运行](https://go.dev/play/p/pJfXXAoG_Te) + +```go +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 + +将字符串转换为驼峰式字符串, 非字母和数字会被忽略。
+ +函数签名: + +```go +func CamelCase(s string) string +``` + +示例:[运行](https://go.dev/play/p/9eXP3tn2tUy) + +```go +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, 非字母和数字会被忽略。
+ +函数签名: + +```go +func KebabCase(s string) string +``` + +示例:[运行](https://go.dev/play/p/dcZM9Oahw-Y) + +```go +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, 非字母和数字会被忽略。
+ +函数签名: + +```go +func UpperKebabCase(s string) string +``` + +示例:[运行](https://go.dev/play/p/zDyKNneyQXk) + +```go +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 + +将字符串的第一个字符转换为大写。
+ +函数签名: + +```go +func Capitalize(s string) string +``` + +示例:[运行](https://go.dev/play/p/2OAjgbmAqHZ) + +```go +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 + +判断传入参数的数据类型是否为字符串。
+ +函数签名: + +```go +func IsString(v any) bool +``` + +示例:[运行](https://go.dev/play/p/IOgq7oF9ERm) + +```go +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 + +将字符串的第一个字符转换为小写。
+ +函数签名: + +```go +func LowerFirst(s string) string +``` + +示例:[运行](https://go.dev/play/p/CbzAyZmtJwL) + +```go +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 + +将字符串的第一个字符转换为大写形式。
+ +函数签名: + +```go +func UpperFirst(s string) string +``` + +示例:[运行](https://go.dev/play/p/sBbBxRbs8MM) + +```go +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，则在左右两侧填充字符串。
+ +函数签名: + +```go +func Pad(source string, size int, padStr string) string +``` + +示例:[运行](https://go.dev/play/p/NzImQq-VF8q) + +```go +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，则在右侧填充字符串。
+ +函数签名: + +```go +func PadEnd(source string, size int, padStr string) string +``` + +示例:[运行](https://go.dev/play/p/9xP8rN0vz--) + +```go +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，则在左侧填充字符串。
+ +函数签名: + +```go +func PadStart(source string, size int, padStr string) string +``` + +示例:[运行](https://go.dev/play/p/xpTfzArDfvT) + +```go +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 + +返回字符顺序与给定字符串相反的字符串。
+ +函数签名: + +```go +func Reverse(s string) string +``` + +示例:[运行](https://go.dev/play/p/adfwalJiecD) + +```go +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形式, 非字母和数字会被忽略。
+ +函数签名: + +```go +func SnakeCase(s string) string +``` + +示例:[运行](https://go.dev/play/p/tgzQG11qBuN) + +```go +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形式, 非字母和数字会被忽略。
+ +函数签名: + +```go +func UpperSnakeCase(s string) string +``` + +示例:[运行](https://go.dev/play/p/4COPHpnLx38) + +```go +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参数指定是否去除空字符串。
+ +函数签名: + +```go +func SplitEx(s, sep string, removeEmptyString bool) []string +``` + +示例:[运行](https://go.dev/play/p/Us-ySSbWh-3) + +```go +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 + +根据指定的位置和长度截取字符串。
+ +函数签名: + +```go +func Substring(s string, offset int, length uint) string +``` + +示例:[运行](https://go.dev/play/p/q3sM6ehnPDp) + +```go +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 + +用另一个字符串包裹一个字符串。
+ +函数签名: + +```go +func Wrap(str string, wrapWith string) string +``` + +示例:[运行](https://go.dev/play/p/KoZOlZDDt9y) + +```go +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'' + // +} +``` + +### Unwrap + +用另一个字符串解开包裹一个字符串。
+ +函数签名: + +```go +func Unwrap(str string, wrapToken string) string +``` + +示例:[运行](https://go.dev/play/p/Ec2q4BzCpG-) + +```go +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 + +将字符串拆分为单词，只支持字母字符单词。
+ +函数签名: + +```go +func SplitWords(s string) []string +``` + +示例:[运行](https://go.dev/play/p/KLiX4WiysMM) + +```go +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 + +返回有意义单词的数量，只支持字母字符单词。
+ +函数签名: + +```go +func WordCount(s string) int +``` + +示例:[运行](https://go.dev/play/p/bj7_odx3vRf) + +```go +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 + +删除字符串中不可打印的字符。
+ +函数签名: + +```go +func RemoveNonPrintable(str string) string +``` + +示例:[运行](https://go.dev/play/p/og47F5x_jTZ) + +```go +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 + +在不分配内存的情况下将字符串转换为字节片。
+ +函数签名: + +```go +func StringToBytes(str string) (b []byte) +``` + +示例:[运行](https://go.dev/play/p/7OyFBrf9AxA) + +```go +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 + +在不分配内存的情况下将字节切片转换为字符串。
+ +函数签名: + +```go +func BytesToString(bytes []byte) string +``` + +示例:[运行](https://go.dev/play/p/6c68HRvJecH) + +```go +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 + +检查字符串是否为空格或空。
+ +函数签名: + +```go +func IsBlank(str string) bool +``` + +示例:[运行](https://go.dev/play/p/6zXRH_c0Qd3) + +```go +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 + +检查字符串是否以指定字符串数组中的任何一个开头。
+ +函数签名: + +```go +func HasPrefixAny(str string, prefixes []string) bool +``` + +示例:[运行](https://go.dev/play/p/8UUTl2C5slo) + +```go +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 + +检查字符串是否以指定字符串数组中的任何一个结尾。
+ +函数签名: + +```go +func HasSuffixAny(str string, suffixes []string) bool +``` + +示例:[运行](https://go.dev/play/p/sKWpCQdOVkx) + +```go +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。
+ +函数签名: + +```go +func IndexOffset(str string, substr string, idxFrom int) int +``` + +示例:[运行](https://go.dev/play/p/qZo4lV2fomB) + +```go +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 +} +``` + +### ReplaceWithMap + +返回`str`的副本，以无序的方式被map替换，区分大小写。
+ +函数签名: + +```go +func ReplaceWithMap(str string, replaces map[string]string) string +``` + +示例:[运行](https://go.dev/play/p/h3t7CNj2Vvu) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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 指定额外的剥离字符。
+ +函数签名: + +```go +func Trim(str string, characterMask ...string) string +``` + +示例:[运行](https://go.dev/play/p/Y0ilP0NRV3j) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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后为空的元素。
+ +函数签名: + +```go +func SplitAndTrim(str, delimiter string, characterMask ...string) []string +``` + +示例:[运行](https://go.dev/play/p/ZNL6o4SkYQ7) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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]。
+ +函数签名: + +```go +func HideString(origin string, start, end int, replaceChar string) string +``` + +示例:[运行](https://go.dev/play/p/pzbaIVCTreZ) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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 + +判断字符串是否包括全部给定的子字符串切片。
+ +函数签名: + +```go +func ContainsAll(str string, substrs []string) bool +``` + +示例:[运行](https://go.dev/play/p/KECtK2Os4zq) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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 + +判断字符串是否包括给定的子字符串切片中任意一个子字符串。
+ +函数签名: + +```go +func ContainsAny(str string, substrs []string) bool +``` + +示例:[运行](https://go.dev/play/p/dZGSSMB3LXE) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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个空格。
+ +函数签名: + +```go +func RemoveWhiteSpace(str string, repalceAll bool) string +``` + +示例:[运行](https://go.dev/play/p/HzLC9vsTwkf) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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 +} +``` diff --git a/docs/en/api/packages/stream.md b/docs/en/api/packages/stream.md new file mode 100644 index 0000000..87b0d0e --- /dev/null +++ b/docs/en/api/packages/stream.md @@ -0,0 +1,942 @@ +# Stream + +Package stream implements a sequence of elements supporting sequential and operations. This package is an experiment to explore if stream in go can work as the way java does. it's feature is very limited. + + + +## Source: + +- [https://github.com/duke-git/lancet/blob/main/stream/stream.go](https://github.com/duke-git/lancet/blob/main/stream/stream.go) + + + +## Usage: + +```go +import ( + "github.com/duke-git/lancet/v2/stream" +) +``` + + + +## Index + +- [Of](#Of) +- [FromSlice](#FromSlice) +- [FromChannel](#FromChannel) +- [FromRange](#FromRange) +- [Generate](#Generate) +- [Concat](#Concat) +- [Distinct](#Distinct) +- [Filter](#Filter) +- [Map](#Map) +- [Peek](#Peek) +- [Skip](#Skip) +- [Limit](#Limit) +- [Reverse](#Reverse) +- [Range](#Range) +- [Sorted](#Sorted) +- [ForEach](#ForEach) +- [Reduce](#Reduce) +- [FindFirst](#FindFirst) +- [FindLast](#FindLast) +- [Max](#Max) +- [Min](#Min) +- [AllMatch](#AllMatch) +- [AnyMatch](#AnyMatch) +- [NoneMatch](#NoneMatch) +- [Count](#Count) +- [ToSlice](#ToSlice) + + + + + +## Documentation + +### Of + +Creates a stream whose elements are the specified values.
+ +Signature: + +```go +func Of[T any](elems ...T) stream[T] +``` + +Example:[Run](https://go.dev/play/p/jI6_iZZuVFE) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s := stream.Of(1, 2, 3) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3] +} +``` + +### FromSlice + +Creates a stream from slice.
+ +Signature: + +```go +func FromSlice[T any](source []T) stream[T] +``` + +Example:[Run](https://go.dev/play/p/wywTO0XZtI4) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s := stream.FromSlice([]int{1, 2, 3}) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3] +} +``` + +### FromChannel + +Creates a stream from channel.
+ +Signature: + +```go +func FromChannel[T any](source <-chan T) stream[T] +``` + +Example:[Run](https://go.dev/play/p/9TZYugGMhXZ) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + ch := make(chan int) + go func() { + for i := 1; i < 4; i++ { + ch <- i + } + close(ch) + }() + + s := stream.FromChannel(ch) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3] +} +``` + +### FromRange + +Creates a number stream from start to end. both start and end are included. [start, end]
+ +Signature: + +```go +func FromRange[T constraints.Integer | constraints.Float](start, end, step T) stream[T] +``` + +Example:[Run](https://go.dev/play/p/9Ex1-zcg-B-) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s := stream.FromRange(1, 5, 1) + + data := s.ToSlice() + fmt.Println(data) + + // Output: + // [1 2 3 4 5] +} +``` + +### Generate + +Creates a stream where each element is generated by the provided generater function.
+ +Signature: + +```go +func Generate[T any](generator func() func() (item T, ok bool)) stream[T] +``` + +Example:[Run](https://go.dev/play/p/rkOWL1yA3j9) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + n := 0 + max := 4 + + generator := func() func() (int, bool) { + return func() (int, bool) { + n++ + return n, n < max + } + } + + s := stream.Generate(generator) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3] +} +``` + +### Concat + +Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
+ +Signature: + +```go +func Concat[T any](a, b stream[T]) stream[T] +``` + +Example:[Run](https://go.dev/play/p/HM4OlYk_OUC) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s1 := stream.FromSlice([]int{1, 2, 3}) + s2 := stream.FromSlice([]int{4, 5, 6}) + + s := Concat(s1, s2) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3 4 5 6] +} +``` + +### Distinct + +Creates returns a stream that removes the duplicated items. Support chainable operation
+ +Signature: + +```go +func (s stream[T]) Distinct() stream[T] +``` + +Example:[Run](https://go.dev/play/p/eGkOSrm64cB) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 2, 3, 3, 3}) + distinct := original.Distinct() + + data1 := original.ToSlice() + data2 := distinct.ToSlice() + + fmt.Println(data1) + fmt.Println(data2) + + // Output: + // [1 2 2 3 3 3] + // [1 2 3] +} +``` + +### Filter + +Returns a stream consisting of the elements of this stream that match the given predicate. Support chainable operation
+ +Signature: + +```go +func (s stream[T]) Filter(predicate func(item T) bool) stream[T] +``` + +Example:[Run](https://go.dev/play/p/MFlSANo-buc) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3, 4, 5}) + + isEven := func(n int) bool { + return n%2 == 0 + } + + even := original.Filter(isEven) + + fmt.Println(even.ToSlice()) + + // Output: + // [2 4] +} +``` + +### Map + +Returns a stream consisting of the elements of this stream that apply the given function to elements of stream. Support chainable operation
+ +Signature: + +```go +func (s stream[T]) Map(mapper func(item T) T) stream[T] +``` + +Example:[Run](https://go.dev/play/p/OtNQUImdYko) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + addOne := func(n int) int { + return n + 1 + } + + increament := original.Map(addOne) + + fmt.Println(increament.ToSlice()) + + // Output: + // [2 3 4] +} +``` + +### Peek + +Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream. Support chainable operation
+ +Signature: + +```go +func (s stream[T]) Peek(consumer func(item T)) stream[T] +``` + +Example:[Run](https://go.dev/play/p/u1VNzHs6cb2) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + data := []string{} + peekStream := original.Peek(func(n int) { + data = append(data, fmt.Sprint("value", n)) + }) + + fmt.Println(original.ToSlice()) + fmt.Println(peekStream.ToSlice()) + fmt.Println(data) + + // Output: + // [1 2 3] + // [1 2 3] + // [value1 value2 value3] +} +``` + +### Skip + +Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream. If this stream contains fewer than n elements then an empty stream will be returned. Support chainable operation
+ +Signature: + +```go +func (s stream[T]) Skip(n int) stream[T] +``` + +Example:[Run](https://go.dev/play/p/fNdHbqjahum) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3, 4}) + + s1 := original.Skip(-1) + s2 := original.Skip(0) + s3 := original.Skip(1) + s4 := original.Skip(5) + + fmt.Println(s1.ToSlice()) + fmt.Println(s2.ToSlice()) + fmt.Println(s3.ToSlice()) + fmt.Println(s4.ToSlice()) + + // Output: + // [1 2 3 4] + // [1 2 3 4] + // [2 3 4] + // [] +} +``` + +### Limit + +Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length. Support chainable operation
+ +Signature: + +```go +func (s stream[T]) Limit(maxSize int) stream[T] +``` + +Example:[Run](https://go.dev/play/p/qsO4aniDcGf) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3, 4}) + + s1 := original.Limit(-1) + s2 := original.Limit(0) + s3 := original.Limit(1) + s4 := original.Limit(5) + + fmt.Println(s1.ToSlice()) + fmt.Println(s2.ToSlice()) + fmt.Println(s3.ToSlice()) + fmt.Println(s4.ToSlice()) + + // Output: + // [] + // [] + // [1] + // [1 2 3 4] +} +``` + +### Reverse + +Returns a stream whose elements are reverse order of given stream. Support chainable operation
+ +Signature: + +```go +func (s stream[T]) Reverse() stream[T] +``` + +Example:[Run](https://go.dev/play/p/A8_zkJnLHm4) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + reverse := original.Reverse() + + fmt.Println(reverse.ToSlice()) + + // Output: + // [3 2 1] +} +``` + +### Range + +Returns a stream whose elements are in the range from start(included) to end(excluded) original stream.Support chainable operation
+ +Signature: + +```go +func (s stream[T]) Range(start, end int) stream[T] +``` + +Example:[Run](https://go.dev/play/p/indZY5V2f4j) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + s1 := original.Range(0, 0) + s2 := original.Range(0, 1) + s3 := original.Range(0, 3) + s4 := original.Range(1, 2) + + fmt.Println(s1.ToSlice()) + fmt.Println(s2.ToSlice()) + fmt.Println(s3.ToSlice()) + fmt.Println(s4.ToSlice()) + + // Output: + // [] + // [1] + // [1 2 3] + // [2] +} +``` + +### Sorted + +Returns a stream consisting of the elements of this stream, sorted according to the provided less function.Support chainable operation
+ +Signature: + +```go +func (s stream[T]) Sorted(less func(a, b T) bool) stream[T] +``` + +Example:[Run](https://go.dev/play/p/XXtng5uonFj) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{4, 2, 1, 3}) + + sorted := original.Sorted(func(a, b int) bool { return a < b }) + + fmt.Println(original.ToSlice()) + fmt.Println(sorted.ToSlice()) + + // Output: + // [4 2 1 3] + // [1 2 3 4] +} +``` + +### ForEach + +Performs an action for each element of this stream.
+ +Signature: + +```go +func (s stream[T]) ForEach(action func(item T)) +``` + +Example:[Run](https://go.dev/play/p/Dsm0fPqcidk) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result := 0 + original.ForEach(func(item int) { + result += item + }) + + fmt.Println(result) + + // Output: + // 6 +} +``` + +### Reduce + +Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any.
+ +Signature: + +```go +func (s stream[T]) Reduce(initial T, accumulator func(a, b T) T) T +``` + +Example:[Run](https://go.dev/play/p/6uzZjq_DJLU) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result := original.Reduce(0, func(a, b int) int { + return a + b + }) + + fmt.Println(result) + + // Output: + // 6 +} +``` + +### FindFirst + +Returns the first element of this stream and true, or zero value and false if the stream is empty.
+ +Signature: + +```go +func (s stream[T]) FindFirst() (T, bool) +``` + +Example:[Run](https://go.dev/play/p/9xEf0-6C1e3) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result, ok := original.FindFirst() + + fmt.Println(result) + fmt.Println(ok) + + // Output: + // 1 + // true +} +``` + +### FindLast + +Returns the last element of this stream and true, or zero value and false if the stream is empty.
+ +Signature: + +```go +func (s stream[T]) FindLast() (T, bool) +``` + +Example:[Run](https://go.dev/play/p/WZD2rDAW-2h) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{3, 2, 1}) + + result, ok := original.FindLast() + + fmt.Println(result) + fmt.Println(ok) + + // Output: + // 1 + // true +} +``` + +### Max + +Returns the maximum element of this stream according to the provided less function. less fuction: a > b
+ +Signature: + +```go +func (s stream[T]) Max(less func(a, b T) bool) (T, bool) +``` + +Example:[Run](https://go.dev/play/p/fm-1KOPtGzn) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{4, 2, 1, 3}) + + max, ok := original.Max(func(a, b int) bool { return a > b }) + + fmt.Println(max) + fmt.Println(ok) + + // Output: + // 4 + // true +} +``` + +### Min + +Returns the minimum element of this stream according to the provided less function. less fuction: a < b
+ +Signature: + +```go +func (s stream[T]) Min(less func(a, b T) bool) (T, bool) +``` + +Example:[Run](https://go.dev/play/p/vZfIDgGNRe_0) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{4, 2, 1, 3}) + + min, ok := original.Min(func(a, b int) bool { return a < b }) + + fmt.Println(min) + fmt.Println(ok) + + // Output: + // 1 + // true +} +``` + +### AllMatch + +Returns whether all elements of this stream match the provided predicate.
+ +Signature: + +```go +func (s stream[T]) AllMatch(predicate func(item T) bool) bool +``` + +Example:[Run](https://go.dev/play/p/V5TBpVRs-Cx) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result1 := original.AllMatch(func(item int) bool { + return item > 0 + }) + + result2 := original.AllMatch(func(item int) bool { + return item > 1 + }) + + fmt.Println(result1) + fmt.Println(result2) + + // Output: + // true + // false +} +``` + +### AnyMatch + +Returns whether any elements of this stream match the provided predicate.
+ +Signature: + +```go +func (s stream[T]) AnyMatch(predicate func(item T) bool) bool +``` + +Example:[Run](https://go.dev/play/p/PTCnWn4OxSn) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result1 := original.AnyMatch(func(item int) bool { + return item > 1 + }) + + result2 := original.AnyMatch(func(item int) bool { + return item > 3 + }) + + fmt.Println(result1) + fmt.Println(result2) + + // Output: + // true + // false +} +``` + +### NoneMatch + +Returns whether no elements of this stream match the provided predicate.
+ +Signature: + +```go +func (s stream[T]) NoneMatch(predicate func(item T) bool) bool +``` + +Example:[Run](https://go.dev/play/p/iWS64pL1oo3) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + original := stream.FromSlice([]int{1, 2, 3}) + + result1 := original.NoneMatch(func(item int) bool { + return item > 3 + }) + + result2 := original.NoneMatch(func(item int) bool { + return item > 1 + }) + + fmt.Println(result1) + fmt.Println(result2) + + // Output: + // true + // false +} +``` + +### Count + +Returns the count of elements in the stream.
+ +Signature: + +```go +func (s stream[T]) Count() int +``` + +Example:[Run](https://go.dev/play/p/r3koY6y_Xo-) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s1 := stream.FromSlice([]int{1, 2, 3}) + s2 := stream.FromSlice([]int{}) + + fmt.Println(s1.Count()) + fmt.Println(s2.Count()) + + // Output: + // 3 + // 0 +} +``` + +### ToSlice + +Returns the elements in the stream.
+ +Signature: + +```go +func (s stream[T]) ToSlice() []T +``` + +Example:[Run](https://go.dev/play/p/jI6_iZZuVFE) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/stream" +) + +func main() { + s := stream.Of(1, 2, 3) + + data := s.ToSlice() + + fmt.Println(data) + + // Output: + // [1 2 3] +} +``` diff --git a/docs/en/api/packages/struct.md b/docs/en/api/packages/struct.md new file mode 100644 index 0000000..4c91187 --- /dev/null +++ b/docs/en/api/packages/struct.md @@ -0,0 +1,535 @@ +# Structs + +Struct is abstract struct for provide several high level functions + + + +## Source: + +- [https://github.com/duke-git/lancet/blob/main/structs/struct.go](https://github.com/duke-git/lancet/blob/main/structs/struct.go) + +- [https://github.com/duke-git/lancet/blob/main/structs/field.go](https://github.com/duke-git/lancet/blob/main/structs/field.go) + + + +## Usage: + +```go +import ( + "github.com/duke-git/lancet/v2/structs" +) +``` + + + +## Index: + +- [New](#New) +- [ToMap](#ToMap) +- [Fields](#Fields) +- [Field](#Field) +- [IsStruct](#IsStruct) +- [Tag](#Tag) +- [Name](#Name) +- [Value](#Value) +- [Kind](#Kind) +- [IsEmbedded](#IsEmbedded) +- [IsExported](#IsExported) +- [IsZero](#IsZero) +- [IsSlice](#IsSlice) + + + +## Documentation: + +### New + +The constructor function of the `Struct`
+ +Signature: + +```go +func New(value any, tagName ...string) *Struct +``` + +Example: + +```go +package main + +import ( + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type People struct { + Name string `json:"name"` + } + p1 := &People{Name: "11"} + s := structs.New(p1) + // to do something +} +``` + +### ToMap + +convert a valid struct to a map
+ +Signature: + +```go +func (s *Struct) ToMap() (map[string]any, error) +``` + +> In addition, provided a convenient static function ToMap + +```go +func ToMap(v any) (map[string]any, error) +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type People struct { + Name string `json:"name"` + } + p1 := &People{Name: "11"} + // use constructor function + s1 := structs.New(p1) + m1, _ := s1.ToMap() + + fmt.Println(m1) + + // use static function + m2, _ := structs.ToMap(p1) + + fmt.Println(m2) + + // Output: + // map[name:11] + // map[name:11] +} +``` + +### Fields + +Get all fields of a given struct, that the fields are abstract struct field
+ +Signature: + +```go +func (s *Struct) Fields() []*Field +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type People struct { + Name string `json:"name"` + } + p1 := &People{Name: "11"} + s := structs.New(p1) + fields := s.Fields() + + fmt.Println(len(fields)) + + // Output: + // 1 +} +``` + +### Field + +Get an abstract field of a struct by given field name
+ +Signature: + +```go +func (s *Struct) Field(name string) *Field +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type People struct { + Name string `json:"name"` + } + p1 := &People{Name: "11"} + s := structs.New(p1) + f := s.Field("Name") + + fmt.Println(f.Value()) + + // Output: + // 11 +} +``` + +### IsStruct + +Check if the struct is valid
+ +Signature: + +```go +func (s *Struct) IsStruct() bool +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type People struct { + Name string `json:"name"` + } + p1 := &People{Name: "11"} + s := structs.New(p1) + + fmt.Println(s.IsStruct()) + + // Output: + // true +} +``` + +### Tag + +Get a `Tag` of the `Field`, `Tag` is a abstract struct field tag
+ +Signature: + +```go +func (f *Field) Tag() *Tag +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string `json:"name,omitempty"` + } + p1 := &Parent{"111"} + + s := structs.New(p1) + n, _ := s.Field("Name") + tag := n.Tag() + + fmt.Println(tag.Name) + + // Output: + // name +} +``` + +### Value + +Get the `Field` underlying value
+ +Signature: + +```go +func (f *Field) Value() any +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string `json:"name,omitempty"` + } + p1 := &Parent{"111"} + + s := structs.New(p1) + n, _ := s.Field("Name") + + fmt.Println(n.Value()) + + // Output: + // 111 +} +``` + +### IsEmbedded + +Check if the field is an embedded field
+ +Signature: + +```go +func (f *Field) IsEmbedded() bool +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + } + type Child struct { + Parent + Age int + } + c1 := &Child{} + c1.Name = "111" + c1.Age = 11 + + s := structs.New(c1) + n, _ := s.Field("Name") + a, _ := s.Field("Age") + + fmt.Println(n.IsEmbedded()) + fmt.Println(a.IsEmbedded()) + + // Output: + // true + // false +} +``` + +### IsExported + +Check if the field is exported
+ +Signature: + +```go +func (f *Field) IsExported() bool +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + age int + } + p1 := &Parent{Name: "11", age: 11} + s := structs.New(p1) + n, _ := s.Field("Name") + a, _ := s.Field("age") + + fmt.Println(n.IsExported()) + fmt.Println(a.IsExported()) + + // Output: + // true + // false +} +``` + +### IsZero + +Check if the field is zero value
+ +Signature: + +```go +func (f *Field) IsZero() bool +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + Age int + } + p1 := &Parent{Age: 11} + s := structs.New(p1) + n, _ := s.Field("Name") + a, _ := s.Field("Age") + + fmt.Println(n.IsZero()) + fmt.Println(a.IsZero()) + + // Output: + // true + // false +} +``` + +### Name + +Get the field name
+ +Signature: + +```go +func (f *Field) Name() string +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + Age int + } + p1 := &Parent{Age: 11} + s := structs.New(p1) + n, _ := s.Field("Name") + a, _ := s.Field("Age") + + fmt.Println(n.Name()) + fmt.Println(a.Name()) + + // Output: + // Name + // Age +} +``` + +### Kind + +Get the field's kind
+ +Signature: + +```go +func (f *Field) Kind() reflect.Kind +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + Age int + } + p1 := &Parent{Age: 11} + s := structs.New(p1) + n, _ := s.Field("Name") + a, _ := s.Field("Age") + + fmt.Println(n.Kind()) + fmt.Println(a.Kind()) + + // Output: + // string + // int +} +``` + +### IsSlice + +Check if the field is a slice
+ +Signature: + +```go +func (f *Field) IsSlice() bool +``` + +Example: + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/structs" +) + +func main() { + type Parent struct { + Name string + arr []int + } + + p1 := &Parent{arr: []int{1, 2, 3}} + s := structs.New(p1) + a, _ := s.Field("arr") + + fmt.Println(a.IsSlice()) + + // Output: + // true +} +``` diff --git a/docs/en/api/packages/strutil.md b/docs/en/api/packages/strutil.md new file mode 100644 index 0000000..8e67410 --- /dev/null +++ b/docs/en/api/packages/strutil.md @@ -0,0 +1,1427 @@ +# Strutil + +Package strutil contains some functions to manipulate string. + + + +## Source: + +- [https://github.com/duke-git/lancet/blob/main/strutil/string.go](https://github.com/duke-git/lancet/blob/main/strutil/string.go) + + + +## Usage: + +```go +import ( + "github.com/duke-git/lancet/v2/strutil" +) +``` + + + +## Index + +- [After](#After) +- [AfterLast](#AfterLast) +- [Before](#Before) +- [BeforeLast](#BeforeLast) +- [CamelCase](#CamelCase) +- [Capitalize](#Capitalize) +- [IsString](#IsString) +- [KebabCase](#KebabCase) +- [UpperKebabCase](#UpperKebabCase) +- [LowerFirst](#LowerFirst) +- [UpperFirst](#UpperFirst) +- [Pad](#Pad) +- [PadStart](#PadStart) +- [PadEnd](#PadEnd) +- [Reverse](#Reverse) +- [SnakeCase](#SnakeCase) +- [UpperSnakeCase](#UpperSnakeCase) +- [SplitEx](#SplitEx) +- [Substring](#Substring) +- [Wrap](#Wrap) +- [Unwrap](#Unwrap) +- [SplitWords](#SplitWords) +- [WordCount](#WordCount) +- [RemoveNonPrintable](#RemoveNonPrintable) +- [StringToBytes](#StringToBytes) +- [BytesToString](#BytesToString) +- [IsBlank](#IsBlank) +- [HasPrefixAny](#HasPrefixAny) +- [HasSuffixAny](#HasSuffixAny) +- [IndexOffset](#IndexOffset) +- [ReplaceWithMap](#ReplaceWithMap) +- [Trim](#Trim) +- [SplitAndTrim](#SplitAndTrim) +- [HideString](#HideString) +- [ContainsAll](#ContainsAll) +- [ContainsAny](#ContainsAny) +- [RemoveWhiteSpace](#RemoveWhiteSpace) + + + + + +## Documentation + +### After + +Returns the substring after the first occurrence of a specified string in the source string.
+ +Signature: + +```go +func After(s, char string) string +``` + +Example:[Run](https://go.dev/play/p/RbCOQqCDA7m) + +```go +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: + +```go +func AfterLast(s, char string) string +``` + +Example:[Run](https://go.dev/play/p/1TegARrb8Yn) + +```go +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: + +```go +func Before(s, char string) string +``` + +Example:[Run](https://go.dev/play/p/JAWTZDS4F5w) + +```go +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: + +```go +func BeforeLast(s, char string) string +``` + +Example:[Run](https://go.dev/play/p/pJfXXAoG_Te) + +```go +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: + +```go +func CamelCase(s string) string +``` + +Example:[Run](https://go.dev/play/p/9eXP3tn2tUy) + +```go +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: + +```go +func KebabCase(s string) string +``` + +Example:[Run](https://go.dev/play/p/dcZM9Oahw-Y) + +```go +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: + +```go +func UpperKebabCase(s string) string +``` + +Example:[Run](https://go.dev/play/p/zDyKNneyQXk) + +```go +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: + +```go +func Capitalize(s string) string +``` + +Example:[Run](https://go.dev/play/p/2OAjgbmAqHZ) + +```go +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: + +```go +func IsString(v any) bool +``` + +Example:[Run](https://go.dev/play/p/IOgq7oF9ERm) + +```go +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: + +```go +func LowerFirst(s string) string +``` + +Example:[Run](https://go.dev/play/p/CbzAyZmtJwL) + +```go +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: + +```go +func UpperFirst(s string) string +``` + +Example:[Run](https://go.dev/play/p/sBbBxRbs8MM) + +```go +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 + +Pads string on the left and right side if it's shorter than size.
+ +Signature: + +```go +func Pad(source string, size int, padStr string) string +``` + +Example:[Run](https://go.dev/play/p/NzImQq-VF8q) + +```go +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 + +Pads string on the right side if it's shorter than size.
+ +Signature: + +```go +func PadEnd(source string, size int, padStr string) string +``` + +Example:[Run](https://go.dev/play/p/9xP8rN0vz--) + +```go +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: + +```go +func PadStart(source string, size int, padStr string) string +``` + +Example:[Run](https://go.dev/play/p/xpTfzArDfvT) + +```go +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: + +```go +func Reverse(s string) string +``` + +Example:[Run](https://go.dev/play/p/adfwalJiecD) + +```go +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: + +```go +func SnakeCase(s string) string +``` + +Example:[Run](https://go.dev/play/p/tgzQG11qBuN) + +```go +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: + +```go +func UpperSnakeCase(s string) string +``` + +Example:[Run](https://go.dev/play/p/4COPHpnLx38) + +```go +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: + +```go +func SplitEx(s, sep string, removeEmptyString bool) []string +``` + +Example:[Run](https://go.dev/play/p/Us-ySSbWh-3) + +```go +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: + +```go +func Substring(s string, offset int, length uint) string +``` + +Example:[Run](https://go.dev/play/p/q3sM6ehnPDp) + +```go +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: + +```go +func Wrap(str string, wrapWith string) string +``` + +Example:[Run](https://go.dev/play/p/KoZOlZDDt9y) + +```go +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'' + // +} +``` + +### Unwrap + +Unwrap a given string from anther string. will change source string.
+ +Signature: + +```go +func Unwrap(str string, wrapToken string) string +``` + +Example:[Run](https://go.dev/play/p/Ec2q4BzCpG-) + +```go +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 + +Splits a string into words, word only contains alphabetic characters.
+ +Signature: + +```go +func SplitWords(s string) []string +``` + +Example:[Run](https://go.dev/play/p/KLiX4WiysMM) + +```go +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 + +Return the number of meaningful word, word only contains alphabetic characters.
+ +Signature: + +```go +func WordCount(s string) int +``` + +Example:[Run](https://go.dev/play/p/bj7_odx3vRf) + +```go +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 + +Remove non-printable characters from a string.
+ +Signature: + +```go +func RemoveNonPrintable(str string) string +``` + +Example:[Run](https://go.dev/play/p/og47F5x_jTZ) + +```go +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 + +Converts a string to byte slice without a memory allocation.
+ +Signature: + +```go +func StringToBytes(str string) (b []byte) +``` + +Example:[Run](https://go.dev/play/p/7OyFBrf9AxA) + +```go +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 + +Converts a byte slice to string without a memory allocation.
+ +Signature: + +```go +func BytesToString(bytes []byte) string +``` + +Example:[Run](https://go.dev/play/p/6c68HRvJecH) + +```go +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 + +Checks if a string is whitespace or empty.
+ +Signature: + +```go +func IsBlank(str string) bool +``` + +Example:[Run](https://go.dev/play/p/6zXRH_c0Qd3) + +```go +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 + +Checks if a string starts with any of an array of specified strings.
+ +Signature: + +```go +func HasPrefixAny(str string, prefixes []string) bool +``` + +Example:[Run](https://go.dev/play/p/8UUTl2C5slo) + +```go +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 + +Checks if a string ends with any of an array of specified strings.
+ +Signature: + +```go +func HasSuffixAny(str string, suffixes []string) bool +``` + +Example:[Run](https://go.dev/play/p/sKWpCQdOVkx) + +```go +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 + +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: + +```go +func IndexOffset(str string, substr string, idxFrom int) int +``` + +Example:[Run](https://go.dev/play/p/qZo4lV2fomB) + +```go +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 +} +``` + +### ReplaceWithMap + +Returns a copy of `str`, which is replaced by a map in unordered way, case-sensitively.
+ +Signature: + +```go +func ReplaceWithMap(str string, replaces map[string]string) string +``` + +Example:[Run](https://go.dev/play/p/h3t7CNj2Vvu) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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: + +```go +func Trim(str string, characterMask ...string) string +``` + +Example:[Run](https://go.dev/play/p/Y0ilP0NRV3j) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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: + +```go +func SplitAndTrim(str, delimiter string, characterMask ...string) []string +``` + +Example:[Run](https://go.dev/play/p/ZNL6o4SkYQ7) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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 + +Hide some chars in source string with param `replaceChar`. replace range is origin[start : end]. [start, end).
+ +Signature: + +```go +func HideString(origin string, start, end int, replaceChar string) string +``` + +Example:[Run](https://go.dev/play/p/pzbaIVCTreZ) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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: + +```go +func ContainsAll(str string, substrs []string) bool +``` + +Example:[Run](https://go.dev/play/p/KECtK2Os4zq) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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: + +```go +func ContainsAny(str string, substrs []string) bool +``` + +Example:[Run](https://go.dev/play/p/dZGSSMB3LXE) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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 + +Remove whitespace characters from a string. when set repalceAll is true removes all whitespace, false only replaces consecutive whitespace characters with one space.
+ +Signature: + +```go +func RemoveWhiteSpace(str string, repalceAll bool) string +``` + +Example:[Run](https://go.dev/play/p/HzLC9vsTwkf) + +```go +import ( + "fmt" + "github.com/duke-git/lancet/v2/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 +} +```