Implementing array manipulation functions in JavaScript in Golang
English | 简体ä¸ć–‡
import "github.com/wyb199877/sliceutil"
Iterate over the elements in the slice
func Foreach[T any](
slice []T,
action func(item T, index int, slice []T)
)
sl := []int{1, 2, 3}
sliceutil.Foreach(sl, func(it int, idx int, s []int) {
// ... do something
})
Conversion of elements in slices
func Map[T, R any](
slice []T,
action func(item T, index int, slice []T) R,
) []R
sl := []int{1, 2, 3}
strs := sliceutil.Map(sl, func(it int, idx int, s []int) string {
return strconv.Itoa(it)
})
// strs = ["1" "2" "3"]
Slice element filter
func Filter[T any](
slice []T,
action func(value T, index int, slice []T) bool,
) []T
sl := []int{1, 2, 3}
odds := sliceutil.Filter(sl, func(it int, idx int, s []int) bool {
return it%2 != 0
})
// odds = [1 3]
Slice element accumulator (no initial value implemented)
func Reduce[T any](
slice []T,
action func(result T, item T, index int, slice []T) T,
) T
sl := []int{1, 2, 3}
sum := sliceutil.Reduce(sl, func(ret int, it int, idx int, s []int) int {
return ret + it
})
// sum = 6
Find the first element that satisfies the condition in the slice
func Find[T any](
slice []T,
action func(item T, index int, slice []T) bool,
) (t T, hasFound bool)
sl := []int{1, 2, 3}
target, hasFound := sliceutil.Find(sl, func(it int, idx int, s []int) bool {
return it%2 != 0
})
// target = 1, hasFound = true
target, hasFound = sliceutil.Find(sl, func(it int, idx int, s []int) bool {
return it > 3
})
// target = 0, hasFound = false
Find the index of the first element that meets the condition in the slice
func FindIndex[T any](
slice []T,
action func(item T, index int, slice []T) bool,
) int
sl := []int{1, 2, 3}
index := sliceutil.FindIndex(sl, func(it int, idx int, s []int) bool {
return it%2 != 0
})
// index = 0
index = sliceutil.FindIndex(sl, func(it int, idx int, s []int) bool {
return it > 3
})
// index = -1
Finds the index of the first element that equal to the target value in the slice
func IndexOf[T comparable](slice []T, target T) int
sl := []int{1, 2, 3}
index := sliceutil.IndexOf(sl, 1)
// index = 0
index = sliceutil.IndexOf(sl, 4)
// index = -1
Finds the index of the last element that equal to the target value in the slice
func LastIndexOf[T comparable](slice []T, target T) int
sl := []int{1, 2, 3, 1}
index := sliceutil.LastIndexOf(sl, 1)
// index = 3
index = sliceutil.LastIndexOf(sl, 4)
// index = -1
Determine whether there is an element equal to the target value in the slice
func Includes[T comparable](slice []T, target T) bool
sl := []int{1, 2, 3}
isExist := sliceutil.Includes(sl, 1)
// isExist = true
isExist = sliceutil.Includes(sl, 4)
// isExist = false
Determine if there is an element in the slice that satisfies the condition
func Some[T any](
slice []T,
action func(item T, index int, slice []T) bool,
) bool
sl := []int{1, 3, 5}
isExist := sliceutil.Some(sl, func(it int, idx int, s []int) bool {
return it%2 != 0
})
// isExist = true
isExist = sliceutil.Some(sl, func(it int, idx int, s []int) bool {
return it%2 == 0
})
// isExist = false
Determines whether all elements in the slice satisfy the condition
func Every[T any](
slice []T,
action func(item T, index int, slice []T) bool,
) bool
sl := []int{1, 3, 5}
isEvery := sliceutil.Every(sl, func(it int, idx int, s []int) bool {
return it%2 != 0
})
// isEvery = true
isEvery = sliceutil.Every(sl, func(it int, idx int, s []int) bool {
return it%2 == 0
})
// isEvery = false
Functions under this heading operate directly on the memory space to which the slice address points
Insert elements at the position of index in the slice
func Insert[T any](sp *[]T, index int, items ...T)
sl := []int{1, 3, 4}
sliceutil.Insert(&sl, 1, 2)
// sl = [1 2 3 4]
Removes an element from a slice at the position of index (make sure there is an element at that position)
func Remove[T any](sp *[]T, index int)
sl := []int{1, 3, 4}
sliceutil.Remove(&sl, 1)
// sl = [1 4]
Insert elements at the end of slice
func Push[T any](sp *[]T, items ...T)
sl := []int{1, 2, 3}
sliceutil.Push(&sl, 4)
// sl = [1 2 3 4]
Pops up and returns the last element of a slice (do not operate on empty slices)
func Pop[T any](sp *[]T) T
sl := []int{1, 2, 3}
last := sliceutil.Pop(&sl)
// last = 3, sl = [1 2]
Insert elements at the start of slice
func Unshift[T any](sp *[]T, items ...T)
sl := []int{2, 3, 4}
sliceutil.Unshift(&sl, 1)
// sl = [1 2 3 4]
Pops up and returns the first element of a slice (do not operate on empty slices)
func Shift[T any](sp *[]T) T
sl := []int{1, 2, 3}
first := sliceutil.Shift(&sl)
// first = 1, sl = [2 3]
Reverse the order of the elements in the slice (only copy, no memory space operation)
func Reverse[T any](slice []T) []T
sl := []int{1, 2, 3}
sl = sliceutil.Reverse(sl)
// sl = [3 2 1]
Reverse the order of the elements in the slice (operate the memory space)
func ReverseSelf[T any](slice []T)
sl := []int{1, 2, 3}
sliceutil.ReverseSelf(sl)
// sl = [3 2 1]
Convert slice to map
func ToMap[T any, K comparable, V any](
slice []T,
key func(item T) K,
value func(item T) V,
) map[K]V
sl := []string{"a", "b", "c"}
mp := sliceutil.ToMap(sl, func(it string) string {
return strings.ToUpper(it)
}, func(it string) string {
return it
})
// mp = map[string]string{"A":"a", "B":"b", "C":"c"}
Copy slice
func Copy[T any](slice []T) []T
sl := []int{1, 2, 3, 4}
copied := sliceutil.Copy(sl)
copied[0] = 99
// sl = [1 2 3 4] copied = [99 2 3 4]
Cut, return a copy
func Cut[T any](slice []T, start int, end int) []T
sl := []int{1, 2, 3, 4}
cut := sliceutil.Cut(sl, 1, 3)
cut[0] = 99
// sl = [1, 2, 3, 4] cut = [99, 3]
Cut from first element, return a copy
func CutFromFirst[T any](slice []T, end int) []T
sl := []int{1, 2, 3, 4}
cut := sliceutil.CutFromFirst(sl, 3)
cut[0] = 99
// sl = [1 2 3 4] cut = [99 2 3]
Cut to last element, return a copy
func CutToLast[T any](slice []T, start int) []T
sl := []int{1, 2, 3, 4}
cut := sliceutil.CutToLast(sl, 1)
cut[0] = 99
// sl = [1 2 3 4] cut = [99 3 4]