Fountain

English

Tiếng Việt

English

Tiếng Việt

Appearance

Import path: gitlab.soludian.com/soludian/fountain/libs/base/arr_util

arr_util ​

go
import "gitlab.soludian.com/soludian/fountain/libs/base/arr_util"

Index ​

Variables ​

ErrElementNotFound is the error returned when the element is not found.

go
var ErrElementNotFound = errors.New("element not found")

ErrInvalidType error

go
var ErrInvalidType = errors.New("the input param type is invalid")

func AnyToSlice ​

go
func AnyToSlice(sl any) (ls []any, err error)

AnyToSlice convert any(allow: array,slice) to []any

func AnyToString ​

go
func AnyToString(arr any) string

AnyToString simple and quickly convert any array, slice to string

func AnyToStrings ​

go
func AnyToStrings(arr any) []string

AnyToStrings convert array or slice to []string

func AssertInterfaces ​

go
func AssertInterfaces[T any](is []any) ([]T, error)

AssertInterfaces asserts all members of the passed slice of interfaces to the requested type and returns a slice of that type. A nil slice along with an error is returned if one of the entries cannot be asserted to the destination type.

Example

go
interfaceSlice := []any{"Hello", "World!"}
stringSlice, err := AssertInterfaces[string](interfaceSlice)
if err != nil {
	log.Fatal(err)
}

s := strings.Join(stringSlice, ", ")
fmt.Println(s)

interfaceSlice = []any{1, 1.1, "foobar"}
intSlice, err := AssertInterfaces[int](interfaceSlice)
if err != nil {
	fmt.Println(err)
}

fmt.Println(intSlice)

// Output: Hello, World!
// cannot assert float64 of value 1.1 to int at index 1
// []

Output ​

Hello, World!
cannot assert float64 of value 1.1 to int at index 1
[]

func AssertInterfacesP ​

go
func AssertInterfacesP[T any](is []any) []T

AssertInterfacesP is like AssertInterfaces, only that it does not check for successful assertion and lets the runtime panic if assertion fails. Useful for inlining in cases where you are 100% sure of the concrete type of the passed slice.

Example

go
interfaceSlice := []any{"Hello", "World!"}

s := strings.Join(AssertInterfacesP[string](interfaceSlice), ", ")
fmt.Println(s)

// Output: Hello, World!

Output ​

Hello, World!

func CloneSlice ​

go
func CloneSlice[T any](data []T) []T

CloneSlice Clone a slice.

data: the slice to clone.
returns: the cloned slice.

func Column ​

go
func Column[T any, V any](list []T, mapFn func(obj T) (val V, find bool)) []V

Column alias of Map func

func CombineToMap ​

go
func CombineToMap[K com_def.SortedType, V any](keys []K, values []V) map[K]V

CombineToMap combine []K and []V slice to map[K]V.

If keys length is greater than values, the extra keys will be ignored.

func CombineToSMap ​

go
func CombineToSMap(keys, values []string) map[string]string

CombineToSMap combine two string-slice to map[string]string

func Contains ​

go
func Contains(arr, val any) bool

Contains kiểm tra slice/array(strings, intXs, uintXs) có chứa giá trị cho trước (int(X),string).

TIP: Khác với In(), Contains() sẽ cố gắng chuyển đổi kiểu giá trị, và Contains() hỗ trợ kiểu array. Hàm In mang lại hiệu suất tốt.

func ContainsAll ​

go
func ContainsAll[T com_def.ScalarType](list, values []T) bool

ContainsAll check given values is sub-list of sample list.

func ConvType ​

go
func ConvType[T any, R any](arr []T, newElemTyp R) ([]R, error)

ConvType convert type of slice elements to new type slice, by the given newElemTyp type.

Supports conversion between []string, []intX, []uintX, []floatX.

Usage:

ints, _ := ConvType([]string{"12", "23"}, 1) // []int{12, 23}

func Diff ​

go
func Diff[T any](first, second []T, fn Comparer[T]) []T

Diff Produces the set difference of two slice according to a comparer function. alias of Differences

func Differences ​

go
func Differences[T any](first, second []T, fn Comparer[T]) []T

Differences Produces the set difference of two slice according to a comparer function.

  • first: the first slice. MUST BE A SLICE.
  • second: the second slice. MUST BE A SLICE.
  • fn: the comparer function.
  • returns: the difference of the two slices.

Example:

Output: []string{"c"}
Differences([]string{"a", "b", "c"}, []string{"a", "b"}, StringEqualsComparer

func ElemTypeEqualsComparer ​

go
func ElemTypeEqualsComparer[T any](a, b T) int

ElemTypeEqualsComparer Comparer for struct/value. It will compare the struct by their element type.

returns: 0 if same type, -1 if not.

func ElementExecuteFunc ​

go
func ElementExecuteFunc[T any](lObj []T, fn func(T) T) []T

ElementExecuteFunc applies a provided function to each element in a given slice.

  • lObj: the input slice containing elements of type Obj.
  • fn: the function to be applied to each element in lObj.
  • returns: a new slice containing the results of applying fn to each element in lObj.

Usage:

lObjs := []Obj{obj1, obj2, obj3, ...}
result := ElementExecuteFunc(lObjs, func(o Obj) Obj {
	// Your custom logic to be applied to each element.
	// ...
	return modifiedObj
})
// 'result' now contains the modified elements based on the applied function.

Note: The provided function 'fn' should take an element of type 'Obj' as input and return a value of the same type 'Obj'.

func ExceptWhile ​

go
func ExceptWhile[T any](data []T, fn Predicate[T]) []T

ExceptWhile Produce the set of a slice except with a predicate function, Produce original slice when predicate function not match.

  • data: the slice. MUST BE A SLICE.
  • fn: the predicate function.
  • returns: the set of the slice.

Example:

Output: []string{"a", "b"}
sl := ExceptWhile([]string{"a", "b", "c"}, func(s string) bool {
	return s == "c"
})

func Excepts ​

go
func Excepts[T any](first, second []T, fn Comparer[T]) []T

Excepts Produces the set difference of two slice according to a comparer function.

  • first: the first slice. MUST BE A SLICE.
  • second: the second slice. MUST BE A SLICE.
  • fn: the comparer function.
  • returns: the difference of the two slices.

Example:

Output: []string{"c"}
Excepts([]string{"a", "b", "c"}, []string{"a", "b"}, StringEqualsComparer)

func Filter ​

go
func Filter[T any](ls []T, filter ...com_def.MatchFunc[T]) []T

Filter given slice, default will filter zero value.

Usage:

output: [a, b]
ss := Filter([]string{"a", "", "b", ""})

func Find ​

go
func Find[T any](source []T, fn Predicate[T]) (v T, err error)

Find Produces the value of a slice according to a predicate function.

  • source: the slice. MUST BE A SLICE.
  • fn: the predicate function.
  • returns: the struct/value of the slice.

Example:

Output: "c"
val := Find([]string{"a", "b", "c"}, func(s string) bool {
	return s == "c"
})

func FindIdentityMissingInList ​

go
func FindIdentityMissingInList[Obj any, IdTyp com_def.Compared](ids []IdTyp, lObj []Obj, getIdentity func(Obj) IdTyp) []IdTyp

Finds all missing Identities in list lObj when get by ids Find all Obj by using list ids, need find all id missing in result

  • first: the first slice. MUST BE A SLICE.
  • second: the second slice. MUST BE A SLICE.
  • fn: the getIdentity function.
  • returns: the missing ids in list lObj.

Usage:

ids := []int{1, 2, 3, 4}
res := getObjByIds(ids)
missingIds := FindIdentityMissingInList(ids, res, func(md any) int {return md.ID})

func FindOrDefault ​

go
func FindOrDefault[T any](source []T, fn Predicate[T], defaultValue T) T

FindOrDefault Produce the value f a slice to a predicate function, Produce default value when predicate function not found.

  • source: the slice. MUST BE A SLICE.
  • fn: the predicate function.
  • defaultValue: the default value.
  • returns: the value of the slice.

Example:

Output: "d"
val := FindOrDefault([]string{"a", "b", "c"}, func(s string) bool {
	return s == "d"
}, "d")

func FormatIndent ​

go
func FormatIndent(arr any, indent string) string

FormatIndent array data to string.

func GetRandomOne ​

go
func GetRandomOne[T any](arr []T) T

GetRandomOne get random element from an array/slice

func HasValue ​

go
func HasValue(arr, val any) bool

HasValue check array(strings, intXs, uintXs) should be contained the given value(int(X),string).

func In ​

go
func In[T com_def.ScalarType](value T, list []T) bool

In check the given value whether in the list

func InStrings ​

go
func InStrings[T ~string](elem T, ss []T) bool

InStrings check elem in the ss. alias of StringsHas()

func IndexOf ​

go
func IndexOf[T comparable](val T, list []T) int

IndexOf value in given slice.

func Int64sHas ​

go
func Int64sHas(ints []int64, val int64) bool

Int64sHas check the []int64 contains the given value

func InterfaceSlice ​

go
func InterfaceSlice[T any](slice []T) []any

InterfaceSlice transforms a slice of any type to a slice of any. This can be useful when you have a slice of concrete types that has to be passed to a function that takes a (variadic) slice of any.

Example

go
stringSlice := []string{"Hello", ", ", "World", "!"}
// fmt.Print(stringSlice...): cannot use stringSlice (variable of type []string) as type []any in argument to fmt.Print
fmt.Print(InterfaceSlice(stringSlice)...)

// Output: Hello, World!

Output ​

Hello, World!

func Intersects ​

go
func Intersects[T any](first, second []T, fn Comparer[T]) []T

Intersects Produces to intersect of two slice according to a comparer function.

  • first: the first slice. MUST BE A SLICE.
  • second: the second slice. MUST BE A SLICE.
  • fn: the comparer function.
  • returns: to intersect of the two slices.

Example:

Output: []string{"a", "b"}
Intersects([]string{"a", "b", "c"}, []string{"a", "b"}, ValueEqualsComparer)

func IntsHas ​

go
func IntsHas[T com_def.Integer](ints []T, val T) bool

IntsHas check the []com_def.Integer contains the given value

func IntsToString ​

go
func IntsToString[T com_def.Integer](ints []T) string

IntsToString convert []T to string

func IsParent ​

go
func IsParent[T com_def.ScalarType](values, list []T) bool

IsParent check given values is parent-list of samples.

func IsSubList ​

go
func IsSubList[T com_def.ScalarType](values, list []T) bool

IsSubList check given values is sub-list of sample list.

func JoinSlice ​

go
func JoinSlice(sep string, arr ...any) string

JoinSlice join []any slice to string.

func JoinStrings ​

go
func JoinStrings(sep string, ss ...string) string

JoinStrings alias of strings.Join

func JoinTyped ​

go
func JoinTyped[T any](sep string, arr ...T) string

JoinTyped join typed []T slice to string.

Usage:

JoinTyped(",", 1,2,3) // "1,2,3"
JoinTyped(",", "a","b","c") // "a,b,c"
JoinTyped[any](",", "a",1,"c") // "a,1,c"

func Map ​

go
func Map[T any, V any](list []T, mapFn MapFn[T, V]) []V

Map a list to new list

eg: mapping [object0{},object1{},...] to flatten list [object0.someKey, object1.someKey, ...]

func MustToInt64s ​

go
func MustToInt64s(arr any) []int64

MustToInt64s convert any(allow: array,slice) to []int64

func MustToStrings ​

go
func MustToStrings(arr any) []string

MustToStrings convert array or slice to []string

func NotContains ​

go
func NotContains(arr, val any) bool

NotContains check array(strings, ints, uints) should be not contains the given value.

func NotIn ​

go
func NotIn[T com_def.ScalarType](value T, list []T) bool

NotIn check the given value whether not in the list

func QuietStrings ​

go
func QuietStrings(arr []any) []string

QuietStrings safe convert []any to []string

func RandomOne ​

go
func RandomOne[T any](arr []T) T

RandomOne get random element from an array/slice

func ReflectEqualsComparer ​

go
func ReflectEqualsComparer[T any](a, b T) int

ReflectEqualsComparer Comparer for struct ptr. It will compare by reflect.Value

returns: 0 if equal, -1 if a != b

func Remove ​

go
func Remove[T comparable](ls []T, val T) []T

Remove give element from slice []T.

eg: []string{"site", "user", "info", "0"} -> []string{"site", "user", "info"}

func Reverse ​

go
func Reverse[T any](ls []T)

Reverse any T slice.

eg: []string{"site", "user", "info", "0"} -> []string{"0", "info", "user", "site"}

func Shuffle ​

go
func Shuffle[T any](arr []T) []T

func SliceHas ​

go
func SliceHas[T com_def.ScalarType](slice []T, val T) bool

SliceHas check the slice contains the given value

func SliceToInt64s ​

go
func SliceToInt64s(arr []any) []int64

SliceToInt64s convert []any to []int64

func SliceToString ​

go
func SliceToString(arr ...any) string

SliceToString convert []any to string

func SliceToStrings ​

go
func SliceToStrings(arr []any) []string

SliceToStrings safe convert []any to []string

func StringEqualsComparer ​

go
func StringEqualsComparer(a, b string) int

StringEqualsComparer Comparer for string. It will compare the string by their value.

returns: 0 if equal, -1 if a != b

func StringsAsInts ​

go
func StringsAsInts(ss []string) []int

StringsAsInts convert and ignore error

func StringsFilter ​

go
func StringsFilter(ss []string, filter ...com_def.StringMatchFunc) []string

StringsFilter given strings, default will filter emtpy string.

Usage:

output: [a, b]
ss := StringsFilter([]string{"a", "", "b", ""})

func StringsHas ​

go
func StringsHas[T ~string](ss []T, val T) bool

StringsHas check the []string contains the given element

func StringsJoin ​

go
func StringsJoin(sep string, ss ...string) string

StringsJoin alias of strings.Join

func StringsMap ​

go
func StringsMap(ss []string, mapFn func(s string) string) []string

StringsMap handle each string item, map to new strings

func StringsRemove ​

go
func StringsRemove(ss []string, s string) []string

StringsRemove value form a string slice

func StringsToInts ​

go
func StringsToInts(ss []string) (ints []int, err error)

StringsToInts string slice to int slice

func StringsToSlice ​

go
func StringsToSlice(ss []string) []any

StringsToSlice convert []string to []any

func StringsTryInts ​

go
func StringsTryInts(ss []string) (ints []int, err error)

StringsTryInts string slice to int slice

func TakeWhile ​

go
func TakeWhile[T any](data []T, fn Predicate[T]) []T

TakeWhile Produce the set of a slice according to a predicate function, Produce empty slice when predicate function not matched.

  • data: the slice. MUST BE A SLICE.
  • fn: the predicate function.
  • returns: the set of the slice.

Example:

Output: []string{"a", "b"}
sl := TakeWhile([]string{"a", "b", "c"}, func(s string) bool {
	return s != "c"
})

func ToInt64s ​

go
func ToInt64s(arr any) (ret []int64, err error)

ToInt64s convert any(allow: array,slice) to []int64

func ToString ​

go
func ToString[T any](arr []T) string

ToString simple and quickly convert []T to string

func ToStrings ​

go
func ToStrings(arr any) (ret []string, err error)

ToStrings convert any(allow: array,slice) to []string

func Transform ​

go
func Transform[A any, B any](as []A, transFunc func(A) B) []B

Transform a slice of type 'A' to a slice of type 'B', by calling transFunc for each entry.

Useful when working with slices of different, but similar, struct types and you don't want to write the 'for' loops over and over again.

Example (Itoa)

go
in := []int{1, 2, 3, 4, 5}

out := Transform(in, strconv.Itoa)
fmt.Printf("out is of type %T and contains %v", out, out)

// Output: out is of type []string and contains [1 2 3 4 5]

Output ​

out is of type []string and contains [1 2 3 4 5]

Example (Struct)

go
type A struct {
	ID int32
	S  []string
}

type B struct {
	ID int64
	S  string
}

// define a tranformer function
transFunc := func(a A) B {
	return B{
		ID: int64(a.ID),
		S:  strings.Join(a.S, ", "),
	}
}

in := []A{
	{
		ID: 1,
		S:  []string{"Hello", "World!"},
	},
	{
		ID: 2,
		S:  []string{"foo", "bar"},
	},
	{
		ID: 3,
		S:  []string{"spanac"},
	},
}

// create the transformed slice
out := Transform(in, transFunc)

fmt.Printf("out is of type %T and contains %v", out, out)
// Output: out is of type []arr_util.B and contains [{1 Hello, World!} {2 foo, bar} {3 spanac}]

Output ​

out is of type []arr_util.B and contains [{1 Hello, World!} {2 foo, bar} {3 spanac}]

func TransformErr ​

go
func TransformErr[A any, B any](as []A, transFunc func(A) (B, error)) ([]B, error)

TransformErr is similar to Transform, but it uses a transFunc that can return an error.

TransformErr will fail on the first error returned and returns a wrapped error with index information, along with a partial slice from previous successful operations.

Example (Atoi)

go
in := []string{"1", "2", "3", "4", "5"}

out, err := TransformErr(in, strconv.Atoi)
if err != nil {
	panic(err)
}

fmt.Printf("out is of type %T and contains %v\n", out, out)

// this will cause an error
in = []string{"1", "2", "foo", "4", "5"}

out, err = TransformErr(in, strconv.Atoi)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("out is of type %T and contains %v\n", out, out)

// Output: out is of type []int and contains [1 2 3 4 5]
// transform index 2: strconv.Atoi: parsing "foo": invalid syntax
// out is of type []int and contains [1 2]

Output ​

out is of type []int and contains [1 2 3 4 5]
transform index 2: strconv.Atoi: parsing "foo": invalid syntax
out is of type []int and contains [1 2]

func TrimStrings ​

go
func TrimStrings(ss []string, cutSet ...string) []string

TrimStrings trim string slice item.

Usage:

output: [a, b, c]
	ss := TrimStrings([]string{",a", "b.", ",.c,"}, ",.")

func TwoWaySearch ​

go
func TwoWaySearch[T any](data []T, item T, fn Comparer[T]) (int, error)

TwoWaySearch find specialized element in a slice forward and backward in the same time, should be more quickly.

  • data: the slice to search in. MUST BE A SLICE.
  • item: the element to search.
  • fn: the comparer function.
  • return: the index of the element, or -1 if not found.

func Union ​

go
func Union[T any](first, second []T, fn Comparer[T]) []T

Union Produces the set union of two slice according to a comparer function

  • first: the first slice. MUST BE A SLICE.
  • second: the second slice. MUST BE A SLICE.
  • fn: the comparer function.
  • returns: the union of the two slices.

Example:

Output: []string{"a", "b", "c"}
sl := Union([]string{"a", "b", "c"}, []string{"a", "b"}, ValueEqualsComparer)

func Unique ​

go
func Unique[T comparable](list []T) []T

Unique value in the given slice data.

func ValueEqualsComparer ​

go
func ValueEqualsComparer[T comparable](a, b T) int

ValueEqualsComparer Comparer for com_def.Compared type. It will compare by their value.

returns: 0 if equal, -1 if a != b

type ArrFormatter ​

ArrFormatter struct

go
type ArrFormatter struct {
    com_def.BaseFormatter
    // Prefix string for each element
    Prefix string
    // Indent string for format each element
    Indent string
    // ClosePrefix on before end char: ]
    ClosePrefix string
}

func NewFormatter ​

go
func NewFormatter(arr any) *ArrFormatter

NewFormatter instance

func (*ArrFormatter) Format ​

go
func (f *ArrFormatter) Format() string

Format to string

func (*ArrFormatter) FormatTo ​

go
func (f *ArrFormatter) FormatTo(w io.Writer)

FormatTo to custom buffer

func (*ArrFormatter) String ​

go
func (f *ArrFormatter) String() string

Format to string

func (*ArrFormatter) WithFn ​

go
func (f *ArrFormatter) WithFn(fn func(f *ArrFormatter)) *ArrFormatter

WithFn for config self

func (*ArrFormatter) WithIndent ​

go
func (f *ArrFormatter) WithIndent(indent string) *ArrFormatter

WithIndent string

type Comparer ​

Comparer Function to compare two elements.

go
type Comparer[T any] func(a, b T) int

type Ints ​

Ints type

go
type Ints[T com_def.Integer] []T

func (Ints[T]) First ​

go
func (is Ints[T]) First(defVal ...T) T

First element value.

func (Ints[T]) Has ​

go
func (is Ints[T]) Has(i T) bool

Has given element

func (Ints[T]) Last ​

go
func (is Ints[T]) Last(defVal ...T) T

Last element value.

func (Ints[T]) Len ​

go
func (is Ints[T]) Len() int

Len get length

func (Ints[T]) Less ​

go
func (is Ints[T]) Less(i, j int) bool

Less compare two elements

func (Ints[T]) Sort ​

go
func (is Ints[T]) Sort()

Sort the int slice

func (Ints[T]) String ​

go
func (is Ints[T]) String() string

String to string

func (Ints[T]) Swap ​

go
func (is Ints[T]) Swap(i, j int)

Swap elements by indexes

type MapFn ​

MapFn map handle function type.

go
type MapFn[T any, V any] func(input T) (target V, find bool)

type Predicate ​

Predicate Function to predicate a struct/value satisfies a condition.

go
type Predicate[T any] func(v T) bool

type SortedList ​

SortedList definition for compared type

go
type SortedList[T com_def.Compared] []T

func (SortedList[T]) Contains ​

go
func (ls SortedList[T]) Contains(el T) bool

Contains given element

func (SortedList[T]) Filter ​

go
func (ls SortedList[T]) Filter(filter ...com_def.MatchFunc[T]) SortedList[T]

Filter the slice, default will filter zero value.

func (SortedList[T]) First ​

go
func (ls SortedList[T]) First(defVal ...T) T

First element value.

func (SortedList[T]) Has ​

go
func (ls SortedList[T]) Has(el T) bool

Has given element

func (SortedList[T]) IsEmpty ​

go
func (ls SortedList[T]) IsEmpty() bool

IsEmpty check

func (SortedList[T]) Last ​

go
func (ls SortedList[T]) Last(defVal ...T) T

Last element value.

func (SortedList[T]) Len ​

go
func (ls SortedList[T]) Len() int

Len get length

func (SortedList[T]) Less ​

go
func (ls SortedList[T]) Less(i, j int) bool

Less compare two elements

func (SortedList[T]) Remove ​

go
func (ls SortedList[T]) Remove(el T) SortedList[T]

Remove given element

func (SortedList[T]) Sort ​

go
func (ls SortedList[T]) Sort()

Sort the slice

func (SortedList[T]) String ​

go
func (ls SortedList[T]) String() string

String to string

func (SortedList[T]) Swap ​

go
func (ls SortedList[T]) Swap(i, j int)

Swap elements by indexes

type Strings ​

Strings type

go
type Strings []string

func (Strings) Contains ​

go
func (ss Strings) Contains(sub string) bool

Contains given element

func (Strings) First ​

go
func (ss Strings) First(defVal ...string) string

First element value.

func (Strings) Has ​

go
func (ss Strings) Has(sub string) bool

Has given element

func (Strings) Join ​

go
func (ss Strings) Join(sep string) string

Join to string

func (Strings) Last ​

go
func (ss Strings) Last(defVal ...string) string

Last element value.

func (Strings) Sort ​

go
func (ss Strings) Sort()

Sort the string slice

func (Strings) String ​

go
func (ss Strings) String() string

String to string

Generated by gomarkdoc