slice

package
v0.0.0-...-654d6e8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 17, 2024 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Overview

Package slice implements some functions to manipulate slice.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func AppendIfAbsent 

func AppendIfAbsent[T comparable](slice []T, item T) []T

AppendIfAbsent only absent append the item. Play: https://go.dev/play/p/KcC1QXQ-RkL

Example 
result1 := AppendIfAbsent([]string{"a", "b"}, "b")
result2 := AppendIfAbsent([]string{"a", "b"}, "c")

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

Output:

[a b]
[a b c]

func Break 

func Break[T any](values []T, predicate func(T) bool) ([]T, []T)

Breaks a list into two parts at the point where the predicate for the first time is true. Play: https://go.dev/play/p/yLYcBTyeQIz

Example 
nums := []int{1, 2, 3, 4, 5}
even := func(n int) bool { return n%2 == 0 }

resultEven, resultAfterFirstEven := Break(nums, even)
fmt.Println(resultEven)
fmt.Println(resultAfterFirstEven)

Output:

[1]
[2 3 4 5]

func Chunk 

func Chunk[T any](slice []T, size int) [][]T

Chunk creates a slice of elements split into groups the length of size. Play: https://go.dev/play/p/b4Pou5j2L_C

Example 
arr := []string{"a", "b", "c", "d", "e"}

result1 := Chunk(arr, 1)
result2 := Chunk(arr, 2)
result3 := Chunk(arr, 3)
result4 := Chunk(arr, 4)
result5 := Chunk(arr, 5)

fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)

Output:

[[a] [b] [c] [d] [e]]
[[a b] [c d] [e]]
[[a b c] [d e]]
[[a b c d] [e]]
[[a b c d e]]

func Compact 

func Compact[T comparable](slice []T) []T

Compact creates a slice with all falsey values removed. The values false, nil, 0, and "" are falsey. Play: https://go.dev/play/p/pO5AnxEr3TK

Example 
result1 := Compact([]int{0})
result2 := Compact([]int{0, 1, 2, 3})
result3 := Compact([]string{"", "a", "b", "0"})
result4 := Compact([]bool{false, true, true})

fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)

Output:

[]
[1 2 3]
[a b 0]
[true true]

func Concat 

func Concat[T any](slice []T, slices ...[]T) []T

Concat creates a new slice concatenating slice with any additional slices. Play: https://go.dev/play/p/gPt-q7zr5mk

Example 
result1 := Concat([]int{1, 2}, []int{3, 4})
result2 := Concat([]string{"a", "b"}, []string{"c"}, []string{"d"})

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

Output:

[1 2 3 4]
[a b c d]

func Contain 

func Contain[T comparable](slice []T, target T) bool

Contain check if the target value is in the slice or not. Play: https://go.dev/play/p/_454yEHcNjf

Example 
result1 := Contain([]string{"a", "b", "c"}, "a")
result2 := Contain([]int{1, 2, 3}, 4)

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

Output:

true
false

func ContainBy 

func ContainBy[T any](slice []T, predicate func(item T) bool) bool

ContainBy returns true if predicate function return true. Play: https://go.dev/play/p/49tkHfX4GNc

Example 
type foo struct {
	A string
	B int
}

array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
result1 := ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
result2 := ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })

array2 := []string{"a", "b", "c"}
result3 := ContainBy(array2, func(t string) bool { return t == "a" })
result4 := ContainBy(array2, func(t string) bool { return t == "d" })

fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)

Output:

true
false
true
false

func ContainSubSlice 

func ContainSubSlice[T comparable](slice, subSlice []T) bool

ContainSubSlice check if the slice contain a given subslice or not. Play: https://go.dev/play/p/bcuQ3UT6Sev

Example 
result1 := ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "b"})
result2 := ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "d"})

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

Output:

true
false

func Count 

func Count[T comparable](slice []T, item T) int

Count returns the number of occurrences of the given item in the slice. Play: https://go.dev/play/p/Mj4oiEnQvRJ

Example 
nums := []int{1, 2, 3, 3, 4}

result1 := Count(nums, 1)
result2 := Count(nums, 3)

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

Output:

1
2

func CountBy 

func CountBy[T any](slice []T, predicate func(index int, item T) bool) int

CountBy iterates over elements of slice with predicate function, returns the number of all matched elements. Play: https://go.dev/play/p/tHOccTMDZCC

Example 
nums := []int{1, 2, 3, 4, 5}

isEven := func(i, num int) bool {
	return num%2 == 0
}

result := CountBy(nums, isEven)

fmt.Println(result)

Output:

2

func DeleteAt 

func DeleteAt[T any](slice []T, index int) []T

DeleteAt delete the element of slice at index. Play: https://go.dev/play/p/800B1dPBYyd

Example 
chars := []string{"a", "b", "c", "d", "e"}

result1 := DeleteAt(chars, 0)
result2 := DeleteAt(chars, 4)
result3 := DeleteAt(chars, 5)
result4 := DeleteAt(chars, 6)

fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)

Output:

[b c d e]
[a b c d]
[a b c d]
[a b c d]

func DeleteRange 

func DeleteRange[T any](slice []T, start, end int) []T

DeleteRange delete the element of slice from start index to end index（exclude). Play: https://go.dev/play/p/945HwiNrnle

Example 
chars := []string{"a", "b", "c", "d", "e"}

result1 := DeleteRange(chars, 0, 0)
result2 := DeleteRange(chars, 0, 1)
result3 := DeleteRange(chars, 0, 3)
result4 := DeleteRange(chars, 0, 4)
result5 := DeleteRange(chars, 0, 5)

fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)

Output:

[a b c d e]
[b c d e]
[d e]
[e]
[]

func Difference 

func Difference[T comparable](slice, comparedSlice []T) []T

Difference creates a slice of whose element in slice but not in comparedSlice. Play: https://go.dev/play/p/VXvadzLzhDa

Example 
slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{4, 5, 6}

result := Difference(slice1, slice2)

fmt.Println(result)

Output:

[1 2 3]

func DifferenceBy 

func DifferenceBy[T comparable](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T

DifferenceBy it accepts iteratee which is invoked for each element of slice and values to generate the criterion by which they're compared. like lodash.js differenceBy: https://lodash.com/docs/4.17.15#differenceBy. Play: https://go.dev/play/p/DiivgwM5OnC

Example 
slice1 := []int{1, 2, 3, 4, 5} //after add one: 2 3 4 5 6
slice2 := []int{3, 4, 5}       //after add one: 4 5 6

addOne := func(i int, v int) int {
	return v + 1
}

result := DifferenceBy(slice1, slice2, addOne)

fmt.Println(result)

Output:

[1 2]

func DifferenceWith 

func DifferenceWith[T any](slice []T, comparedSlice []T, comparator func(item1, item2 T) bool) []T

DifferenceWith accepts comparator which is invoked to compare elements of slice to values. The order and references of result values are determined by the first slice. The comparator is invoked with two arguments: (arrVal, othVal). Play: https://go.dev/play/p/v2U2deugKuV

Example 
slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{4, 5, 6, 7, 8}

isDouble := func(v1, v2 int) bool {
	return v2 == 2*v1
}

result := DifferenceWith(slice1, slice2, isDouble)

fmt.Println(result)

Output:

[1 5]

func Drop 

func Drop[T any](slice []T, n int) []T

Drop drop n elements from the start of a slice. Play: https://go.dev/play/p/jnPO2yQsT8H

Example 
result1 := Drop([]string{"a", "b", "c"}, 0)
result2 := Drop([]string{"a", "b", "c"}, 1)
result3 := Drop([]string{"a", "b", "c"}, -1)
result4 := Drop([]string{"a", "b", "c"}, 4)

fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)

Output:

[a b c]
[b c]
[a b c]
[]

func DropRight 

func DropRight[T any](slice []T, n int) []T

DropRight drop n elements from the end of a slice. Play: https://go.dev/play/p/8bcXvywZezG

Example 
result1 := DropRight([]string{"a", "b", "c"}, 0)
result2 := DropRight([]string{"a", "b", "c"}, 1)
result3 := DropRight([]string{"a", "b", "c"}, -1)
result4 := DropRight([]string{"a", "b", "c"}, 4)

fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)

Output:

[a b c]
[a b]
[a b c]
[]

func DropRightWhile 

func DropRightWhile[T any](slice []T, predicate func(item T) bool) []T

DropRightWhile drop n elements from the end of a slice while predicate function returns true. Play: https://go.dev/play/p/6wyK3zMY56e

Example 
numbers := []int{1, 2, 3, 4, 5}

result1 := DropRightWhile(numbers, func(n int) bool {
	return n != 2
})
result2 := DropRightWhile(numbers, func(n int) bool {
	return true
})
result3 := DropRightWhile(numbers, func(n int) bool {
	return n == 0
})

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

Output:

[1 2]
[]
[1 2 3 4 5]

func DropWhile 

func DropWhile[T any](slice []T, predicate func(item T) bool) []T

DropWhile drop n elements from the start of a slice while predicate function returns true. Play: https://go.dev/play/p/4rt252UV_qs

Example 
numbers := []int{1, 2, 3, 4, 5}

result1 := DropWhile(numbers, func(n int) bool {
	return n != 2
})
result2 := DropWhile(numbers, func(n int) bool {
	return true
})
result3 := DropWhile(numbers, func(n int) bool {
	return n == 0
})

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

Output:

[2 3 4 5]
[]
[1 2 3 4 5]

func Equal 

func Equal[T comparable](slice1, slice2 []T) bool

Equal checks if two slices are equal: the same length and all elements' order and value are equal. Play: https://go.dev/play/p/WcRQJ37ifPa

Example 
slice1 := []int{1, 2, 3}
slice2 := []int{1, 2, 3}
slice3 := []int{1, 3, 2}

result1 := Equal(slice1, slice2)
result2 := Equal(slice1, slice3)

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

Output:

true
false

func EqualWith 

func EqualWith[T, U any](slice1 []T, slice2 []U, comparator func(T, U) bool) bool

EqualWith checks if two slices are equal with comparator func. Play: https://go.dev/play/p/b9iygtgsHI1

Example 
slice1 := []int{1, 2, 3}
slice2 := []int{2, 4, 6}

isDouble := func(a, b int) bool {
	return b == a*2
}

result := EqualWith(slice1, slice2, isDouble)

fmt.Println(result)

Output:

true

func Every 

func Every[T any](slice []T, predicate func(index int, item T) bool) bool

Every return true if all of the values in the slice pass the predicate function. Play: https://go.dev/play/p/R8U6Sl-j8cD

Example 
nums := []int{1, 2, 3, 5}

isEven := func(i, num int) bool {
	return num%2 == 0
}

result := Every(nums, isEven)

fmt.Println(result)

Output:

false

func Filter 

func Filter[T any](slice []T, predicate func(index int, item T) bool) []T

Filter iterates over elements of slice, returning an slice of all elements pass the predicate function. Play: https://go.dev/play/p/SdPna-7qK4T

Example 
nums := []int{1, 2, 3, 4, 5}

isEven := func(i, num int) bool {
	return num%2 == 0
}

result := Filter(nums, isEven)

fmt.Println(result)

Output:

[2 4]

func FilterMap 

func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U

FilterMap returns a slice which apply both filtering and mapping to the given slice. iteratee callback function should returntwo values: 1, mapping result. 2, whether the result element should be included or not Play: https://go.dev/play/p/J94SZ_9MiIe

Example 
nums := []int{1, 2, 3, 4, 5}

getEvenNumStr := func(i, num int) (string, bool) {
	if num%2 == 0 {
		return strconv.FormatInt(int64(num), 10), true
	}
	return "", false
}

result := FilterMap(nums, getEvenNumStr)

fmt.Printf("%#v", result)

Output:

[]string{"2", "4"}

func Find 

func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)

Find iterates over elements of slice, returning the first one that passes a truth test on predicate function. If return T is nil then no items matched the predicate func. Play: https://go.dev/play/p/CBKeBoHVLgq Deprecated

Example 
nums := []int{1, 2, 3, 4, 5}

isEven := func(i, num int) bool {
	return num%2 == 0
}

result, ok := Find(nums, isEven)

fmt.Println(*result)
fmt.Println(ok)

Output:

2
true

func FindBy 

func FindBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)

FindBy iterates over elements of slice, returning the first one that passes a truth test on predicate function. If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing Play: https://go.dev/play/p/n1lysBYl-GB

Example 
nums := []int{1, 2, 3, 4, 5}

isEven := func(i, num int) bool {
	return num%2 == 0
}

result, ok := FindBy(nums, isEven)

fmt.Println(result)
fmt.Println(ok)

Output:

2
true

func FindLast 

func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)

FindLast iterates over elements of slice from end to begin, return the first one that passes a truth test on predicate function. If return T is nil then no items matched the predicate func. Play: https://go.dev/play/p/FFDPV_j7URd Deprecated

Example 
nums := []int{1, 2, 3, 4, 5}

isEven := func(i, num int) bool {
	return num%2 == 0
}

result, ok := FindLast(nums, isEven)

fmt.Println(*result)
fmt.Println(ok)

Output:

4
true

func FindLastBy 

func FindLastBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)

FindLastBy iterates over elements of slice, returning the last one that passes a truth test on predicate function. If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing Play: https://go.dev/play/p/8iqomzyCl_s

Example 
nums := []int{1, 2, 3, 4, 5}

isEven := func(i, num int) bool {
	return num%2 == 0
}

result, ok := FindLastBy(nums, isEven)

fmt.Println(result)
fmt.Println(ok)

Output:

4
true

func FlatMap 

func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U

FlatMap manipulates a slice and transforms and flattens it to a slice of another type. Play: https://go.dev/play/p/_QARWlWs1N_F

Example 
nums := []int{1, 2, 3, 4}

result := FlatMap(nums, func(i int, num int) []string {
	s := "hi-" + strconv.FormatInt(int64(num), 10)
	return []string{s}
})

fmt.Printf("%#v", result)

Output:

[]string{"hi-1", "hi-2", "hi-3", "hi-4"}

func Flatten 

func Flatten(slice any) any

Flatten flattens slice with one level. Play: https://go.dev/play/p/hYa3cBEevtm

Example 
arrs := [][][]string{{{"a", "b"}}, {{"c", "d"}}}

result := Flatten(arrs)

fmt.Println(result)

Output:

[[a b] [c d]]

func FlattenDeep 

func FlattenDeep(slice any) any

FlattenDeep flattens slice recursive. Play: https://go.dev/play/p/yjYNHPyCFaF

Example 
arrs := [][][]string{{{"a", "b"}}, {{"c", "d"}}}

result := FlattenDeep(arrs)

fmt.Println(result)

Output:

[a b c d]

func ForEach 

func ForEach[T any](slice []T, iteratee func(index int, item T))

ForEach iterates over elements of slice and invokes function for each element. Play: https://go.dev/play/p/DrPaa4YsHRF

Example 
nums := []int{1, 2, 3}

var result []int
addOne := func(_ int, v int) {
	result = append(result, v+1)
}

ForEach(nums, addOne)

fmt.Println(result)

Output:

[2 3 4]

func ForEachWithBreak 

func ForEachWithBreak[T any](slice []T, iteratee func(index int, item T) bool)

ForEachWithBreak iterates over elements of slice and invokes function for each element, when iteratee return false, will break the for each loop. Play: https://go.dev/play/p/qScs39f3D9W

Example 
numbers := []int{1, 2, 3, 4, 5}

var sum int

ForEachWithBreak(numbers, func(_, n int) bool {
	if n > 3 {
		return false
	}
	sum += n
	return true
})

fmt.Println(sum)

Output:

6

func GroupBy 

func GroupBy[T any](slice []T, groupFn func(index int, item T) bool) ([]T, []T)

GroupBy iterate over elements of the slice, each element will be group by criteria, returns two slices. Play: https://go.dev/play/p/QVkPxzPR0iA

Example 
nums := []int{1, 2, 3, 4, 5}

isEven := func(i, num int) bool {
	return num%2 == 0
}

even, odd := GroupBy(nums, isEven)

fmt.Println(even)
fmt.Println(odd)

Output:

[2 4]
[1 3 5]

func GroupWith 

func GroupWith[T any, U comparable](slice []T, iteratee func(item T) U) map[U][]T

GroupWith return a map composed of keys generated from the resultults of running each element of slice thru iteratee. Play: https://go.dev/play/p/ApCvMNTLO8a

Example 
nums := []float64{6.1, 4.2, 6.3}

floor := func(num float64) float64 {
	return math.Floor(num)
}

result := GroupWith(nums, floor) //map[float64][]float64

fmt.Println(result)

Output:

map[4:[4.2] 6:[6.1 6.3]]

func IndexOf 

func IndexOf[T comparable](arr []T, val T) int

IndexOf returns the index at which the first occurrence of an item is found in a slice or return -1 if the item cannot be found. Play: https://go.dev/play/p/MRN1f0FpABb

Example 
strs := []string{"a", "a", "b", "c"}

result1 := IndexOf(strs, "a")
result2 := IndexOf(strs, "d")

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

Output:

0
-1

func InsertAt 

func InsertAt[T any](slice []T, index int, value any) []T

InsertAt insert the value or other slice into slice at index. Play: https://go.dev/play/p/hMLNxPEGJVE

Example 
result1 := InsertAt([]string{"a", "b", "c"}, 0, "1")
result2 := InsertAt([]string{"a", "b", "c"}, 1, "1")
result3 := InsertAt([]string{"a", "b", "c"}, 2, "1")
result4 := InsertAt([]string{"a", "b", "c"}, 3, "1")
result5 := InsertAt([]string{"a", "b", "c"}, 0, []string{"1", "2", "3"})

fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)

Output:

[1 a b c]
[a 1 b c]
[a b 1 c]
[a b c 1]
[1 2 3 a b c]

func IntSlice 

func IntSlice(slice any) []int

IntSlice convert param to slice of int. This function is deprecated, use generics feature of go1.18+ for replacement. Play: https://go.dev/play/p/UQDj-on9TGN

Example 
nums := []interface{}{1, 2, 3}

result := IntSlice(nums) //[]int{1, 2, 3}
fmt.Println(result)

Output:

[1 2 3]

func InterfaceSlice 

func InterfaceSlice(slice any) []any

InterfaceSlice convert param to slice of interface. This function is deprecated, use generics feature of go1.18+ for replacement. Play: https://go.dev/play/p/FdQXF0Vvqs-

Example 
strs := []string{"a", "b", "c"}

result := InterfaceSlice(strs) //[]interface{}{"a", "b", "c"}
fmt.Println(result)

Output:

[a b c]

func Intersection 

func Intersection[T comparable](slices ...[]T) []T

Intersection creates a slice of unique elements that included by all slices. Play: https://go.dev/play/p/anJXfB5wq_t

Example 
nums1 := []int{1, 2, 3}
nums2 := []int{2, 3, 4}

result := Intersection(nums1, nums2)

fmt.Println(result)

Output:

[2 3]

func IsAscending 

func IsAscending[T constraints.Ordered](slice []T) bool

IsAscending checks if a slice is ascending order. Play: https://go.dev/play/p/9CtsFjet4SH

Example 
result1 := IsAscending([]int{1, 2, 3, 4, 5})
result2 := IsAscending([]int{5, 4, 3, 2, 1})
result3 := IsAscending([]int{2, 1, 3, 4, 5})

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

Output:

true
false
false

func IsDescending 

func IsDescending[T constraints.Ordered](slice []T) bool

IsDescending checks if a slice is descending order. Play: https://go.dev/play/p/U_LljFXma14

Example 
result1 := IsDescending([]int{5, 4, 3, 2, 1})
result2 := IsDescending([]int{1, 2, 3, 4, 5})
result3 := IsDescending([]int{2, 1, 3, 4, 5})

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

Output:

true
false
false

func IsSorted 

func IsSorted[T constraints.Ordered](slice []T) bool

IsSorted checks if a slice is sorted(ascending or descending). Play: https://go.dev/play/p/nCE8wPLwSA-

Example 
result1 := IsSorted([]int{1, 2, 3, 4, 5})
result2 := IsSorted([]int{5, 4, 3, 2, 1})
result3 := IsSorted([]int{2, 1, 3, 4, 5})

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

Output:

true
true
false

func IsSortedByKey 

func IsSortedByKey[T any, K constraints.Ordered](slice []T, iteratee func(item T) K) bool

IsSortedByKey checks if a slice is sorted by iteratee function. Play: https://go.dev/play/p/tUoGB7DOHI4

Example 
result1 := IsSortedByKey([]string{"a", "ab", "abc"}, func(s string) int {
	return len(s)
})
result2 := IsSortedByKey([]string{"abc", "ab", "a"}, func(s string) int {
	return len(s)
})
result3 := IsSortedByKey([]string{"abc", "a", "ab"}, func(s string) int {
	return len(s)
})

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

Output:

true
true
false

func Join 

func Join[T any](slice []T, separator string) string

Join the slice item with specify separator. Play: https://go.dev/play/p/huKzqwNDD7V

Example 
nums := []int{1, 2, 3, 4, 5}

result1 := Join(nums, ",")
result2 := Join(nums, "-")

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

Output:

1,2,3,4,5
1-2-3-4-5

func KeyBy 

func KeyBy[T any, U comparable](slice []T, iteratee func(item T) U) map[U]T

KeyBy converts a slice to a map based on a callback function. Play: https://go.dev/play/p/uXod2LWD1Kg

Example 
result := KeyBy([]string{"a", "ab", "abc"}, func(str string) int {
	return len(str)
})

fmt.Println(result)

Output:

map[1:a 2:ab 3:abc]

func LastIndexOf 

func LastIndexOf[T comparable](slice []T, item T) int

LastIndexOf returns the index at which the last occurrence of the item is found in a slice or return -1 if the then cannot be found. Play: https://go.dev/play/p/DokM4cf1IKH

Example 
strs := []string{"a", "a", "b", "c"}

result1 := LastIndexOf(strs, "a")
result2 := LastIndexOf(strs, "d")

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

Output:

1
-1

func LeftPadding 

func LeftPadding[T any](slice []T, paddingValue T, paddingLength int) []T

LeftPadding adds padding to the left begin of a slice. Play: https://go.dev/play/p/jlQVoelLl2k

Example 
nums := []int{1, 2, 3, 4, 5}
padded := LeftPadding(nums, 0, 3)
fmt.Println(padded)

Output:

[0 0 0 1 2 3 4 5]

func Map 

func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U

Map creates an slice of values by running each element of slice thru iteratee function. Play: https://go.dev/play/p/biaTefqPquw

Example 
nums := []int{1, 2, 3}

addOne := func(_ int, v int) int {
	return v + 1
}

result := Map(nums, addOne)

fmt.Println(result)

Output:

[2 3 4]

func Merge 

func Merge[T any](slices ...[]T) []T

Merge all given slices into one slice. Play: https://go.dev/play/p/lbjFp784r9N

Example 
nums1 := []int{1, 2, 3}
nums2 := []int{3, 4}

result := Merge(nums1, nums2)

fmt.Println(result)

Output:

[1 2 3 3 4]

func None 

func None[T any](slice []T, predicate func(index int, item T) bool) bool

None return true if all the values in the slice mismatch the criteria. Play: https://go.dev/play/p/KimdalUlC-T

Example 
nums := []int{1, 3, 5}

isEven := func(i, num int) bool {
	return num%2 == 0
}

result := None(nums, isEven)

fmt.Println(result)

Output:

true

func Partition 

func Partition[T any](slice []T, predicates ...func(item T) bool) [][]T

Partition all slice elements with the evaluation of the given predicate functions. Play: https://go.dev/play/p/lkQ3Ri2NQhV

Example 
nums := []int{1, 2, 3, 4, 5}

result1 := Partition(nums)
result2 := Partition(nums, func(n int) bool { return n%2 == 0 })
result3 := Partition(nums, func(n int) bool { return n == 1 || n == 2 }, func(n int) bool { return n == 2 || n == 3 || n == 4 })

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

Output:

[[1 2 3 4 5]]
[[2 4] [1 3 5]]
[[1 2] [3 4] [5]]

func Random 

func Random[T any](slice []T) (val T, idx int)

Random get a random item of slice, return idx=-1 when slice is empty Play: https://go.dev/play/p/UzpGQptWppw

Example 
nums := []int{1, 2, 3, 4, 5}

val, idx := Random(nums)
if idx >= 0 && idx < len(nums) && Contain(nums, val) {
	fmt.Println("okk")
}

Output:

okk

func Reduce 

func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T

Reduce creates an slice of values by running each element of slice thru iteratee function. Play: https://go.dev/play/p/_RfXJJWIsIm

Example 
nums := []int{1, 2, 3}

sum := func(_ int, v1, v2 int) int {
	return v1 + v2
}

result := Reduce(nums, sum, 0)

fmt.Println(result)

Output:

6

func ReduceBy 

func ReduceBy[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U

ReduceBy produces a value from slice by accumulating the result of each element as passed through the reducer function. Play: https://go.dev/play/p/YKDpLi7gtee

Example 
result1 := ReduceBy([]int{1, 2, 3, 4}, 0, func(_ int, item int, agg int) int {
	return agg + item
})

result2 := ReduceBy([]int{1, 2, 3, 4}, "", func(_ int, item int, agg string) string {
	return agg + fmt.Sprintf("%v", item)
})

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

Output:

10
1234

func ReduceRight 

func ReduceRight[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U

ReduceRight is like ReduceBy, but it iterates over elements of slice from right to left. Play: https://go.dev/play/p/qT9dZC03A1K

Example 
result := ReduceRight([]int{1, 2, 3, 4}, "", func(_ int, item int, agg string) string {
	return agg + fmt.Sprintf("%v", item)
})

fmt.Println(result)

Output:

4321

func Repeat 

func Repeat[T any](item T, n int) []T

Repeat creates a slice with length n whose elements are param `item`. Play: https://go.dev/play/p/1CbOmtgILUU

Example 
result := Repeat("a", 3)

fmt.Println(result)

Output:

[a a a]

func Replace 

func Replace[T comparable](slice []T, old T, new T, n int) []T

Replace returns a copy of the slice with the first n non-overlapping instances of old replaced by new. Play: https://go.dev/play/p/P5mZp7IhOFo

Example 
strs := []string{"a", "b", "c", "a"}

result1 := Replace(strs, "a", "x", 0)
result2 := Replace(strs, "a", "x", 1)
result3 := Replace(strs, "a", "x", 2)
result4 := Replace(strs, "a", "x", 3)
result5 := Replace(strs, "a", "x", -1)

fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)

Output:

[a b c a]
[x b c a]
[x b c x]
[x b c x]
[x b c x]

func ReplaceAll 

func ReplaceAll[T comparable](slice []T, old T, new T) []T

ReplaceAll returns a copy of the slice with all non-overlapping instances of old replaced by new. Play: https://go.dev/play/p/CzqXMsuYUrx

Example 
result := ReplaceAll([]string{"a", "b", "c", "a"}, "a", "x")

fmt.Println(result)

Output:

[x b c x]

func Reverse 

func Reverse[T any](slice []T)

Reverse return slice of element order is reversed to the given slice. Play: https://go.dev/play/p/8uI8f1lwNrQ

Example 
strs := []string{"a", "b", "c", "d"}

Reverse(strs)

fmt.Println(strs)

Output:

[d c b a]

func RightPadding 

func RightPadding[T any](slice []T, paddingValue T, paddingLength int) []T

RightPadding adds padding to the right end of a slice. Play: https://go.dev/play/p/0_2rlLEMBXL

Example 
nums := []int{1, 2, 3, 4, 5}
padded := RightPadding(nums, 0, 3)
fmt.Println(padded)

Output:

[1 2 3 4 5 0 0 0]

func SetToDefaultIf 

func SetToDefaultIf[T any](slice []T, predicate func(T) bool) ([]T, int)

SetToDefaultIf sets elements to their default value if they match the given predicate. It retains the positions of the elements in the slice. It returns slice of T and the count of modified slice items Play: https://go.dev/play/p/9AXGlPRC0-A

Example 
strs := []string{"a", "b", "a", "c", "d", "a"}
modifiedStrs, count := SetToDefaultIf(strs, func(s string) bool { return "a" == s })
fmt.Println(modifiedStrs)
fmt.Println(count)

Output:

[ b  c d ]
3

func Shuffle 

func Shuffle[T any](slice []T) []T

Shuffle the slice. Play: https://go.dev/play/p/YHvhnWGU3Ge

func Some 

func Some[T any](slice []T, predicate func(index int, item T) bool) bool

Some return true if any of the values in the list pass the predicate function. Play: https://go.dev/play/p/4pO9Xf9NDGS

Example 
nums := []int{1, 2, 3, 5}

isEven := func(i, num int) bool {
	return num%2 == 0
}

result := Some(nums, isEven)

fmt.Println(result)

Output:

true

func Sort 

func Sort[T constraints.Ordered](slice []T, sortOrder ...string)

Sort sorts a slice of any ordered type(number or string), use quick sort algrithm. default sort order is ascending (asc), if want descending order, set param `sortOrder` to `desc`. Play: https://go.dev/play/p/V9AVjzf_4Fk

Example 
nums := []int{1, 4, 3, 2, 5}

Sort(nums)

fmt.Println(nums)

Output:

[1 2 3 4 5]

func SortBy 

func SortBy[T any](slice []T, less func(a, b T) bool)

SortBy sorts the slice in ascending order as determined by the less function. This sort is not guaranteed to be stable. Play: https://go.dev/play/p/DAhLQSZEumm

Example 
type User struct {
	Name string
	Age  uint
}

users := []User{
	{Name: "a", Age: 21},
	{Name: "b", Age: 15},
	{Name: "c", Age: 100}}

SortBy(users, func(a, b User) bool {
	return a.Age < b.Age
})

fmt.Println(users)

Output:

[{b 15} {a 21} {c 100}]

func SortByField 

func SortByField[T any](slice []T, field string, sortType ...string) error

SortByField return sorted slice by field slice element should be struct, field type should be int, uint, string, or bool default sortType is ascending (asc), if descending order, set sortType to desc This function is deprecated, use Sort and SortBy for replacement. Play: https://go.dev/play/p/fU1prOBP9p1

Example 
type User struct {
	Name string
	Age  uint
}

users := []User{
	{Name: "a", Age: 21},
	{Name: "b", Age: 15},
	{Name: "c", Age: 100}}

err := SortByField(users, "Age", "desc")
if err != nil {
	return
}

fmt.Println(users)

Output:

[{c 100} {a 21} {b 15}]

func StringSlice 

func StringSlice(slice any) []string

StringSlice convert param to slice of string. This function is deprecated, use generics feature of go1.18+ for replacement. Play: https://go.dev/play/p/W0TZDWCPFcI

Example 
strs := []interface{}{"a", "b", "c"}

result := StringSlice(strs) //[]string{"a", "b", "c"}
fmt.Println(result)

Output:

[a b c]

func SymmetricDifference 

func SymmetricDifference[T comparable](slices ...[]T) []T

SymmetricDifference oppoiste operation of intersection function. Play: https://go.dev/play/p/h42nJX5xMln

Example 
nums1 := []int{1, 2, 3}
nums2 := []int{1, 2, 4}

result := SymmetricDifference(nums1, nums2)

fmt.Println(result)

Output:

[3 4]

func ToSlice 

func ToSlice[T any](items ...T) []T

ToSlice returns a slices of a variable parameter transformation. Play: https://go.dev/play/p/YzbzVq5kscN

Example 
result := ToSlice("a", "b", "c")

fmt.Println(result)

Output:

[a b c]

func ToSlicePointer 

func ToSlicePointer[T any](items ...T) []*T

ToSlicePointer returns a pointer to the slices of a variable parameter transformation. Play: https://go.dev/play/p/gx4tr6_VXSF

Example 
str1 := "a"
str2 := "b"

result := ToSlicePointer(str1, str2)

expect := []*string{&str1, &str2}

isEqual := reflect.DeepEqual(result, expect)

fmt.Println(isEqual)

Output:

true

func Union 

func Union[T comparable](slices ...[]T) []T

Union creates a slice of unique elements, in order, from all given slices. Play: https://go.dev/play/p/hfXV1iRIZOf

Example 
nums1 := []int{1, 3, 4, 6}
nums2 := []int{1, 2, 5, 6}

result := Union(nums1, nums2)

fmt.Println(result)

Output:

[1 3 4 6 2 5]

func UnionBy 

func UnionBy[T any, V comparable](predicate func(item T) V, slices ...[]T) []T

UnionBy is like Union, what's more it accepts iteratee which is invoked for each element of each slice. Play: https://go.dev/play/p/HGKHfxKQsFi

Example 
nums := []int{1, 2, 3, 4}

divideTwo := func(n int) int {
	return n / 2
}
result := UnionBy(divideTwo, nums)

fmt.Println(result)

Output:

[1 2 4]

func Unique 

func Unique[T comparable](slice []T) []T

Unique remove duplicate elements in slice. Play: https://go.dev/play/p/AXw0R3ZTE6a

Example 
result := Unique([]string{"a", "a", "b"})
fmt.Println(result)

Output:

[a b]

func UniqueBy 

func UniqueBy[T comparable](slice []T, iteratee func(item T) T) []T

UniqueBy call iteratee func with every item of slice, then remove duplicated. Play: https://go.dev/play/p/UR323iZLDpv

Example 
nums := []int{1, 2, 3, 4, 5, 6}
result := UniqueBy(nums, func(val int) int {
	return val % 3
})

fmt.Println(result)

Output:

[1 2 0]

func UpdateAt 

func UpdateAt[T any](slice []T, index int, value T) []T

UpdateAt update the slice element at index. Play: https://go.dev/play/p/f3mh2KloWVm

Example 
result1 := UpdateAt([]string{"a", "b", "c"}, -1, "1")
result2 := UpdateAt([]string{"a", "b", "c"}, 0, "1")
result3 := UpdateAt([]string{"a", "b", "c"}, 1, "1")
result4 := UpdateAt([]string{"a", "b", "c"}, 2, "1")
result5 := UpdateAt([]string{"a", "b", "c"}, 3, "1")

fmt.Println(result1)
fmt.Println(result2)
fmt.Println(result3)
fmt.Println(result4)
fmt.Println(result5)

Output:

[a b c]
[1 b c]
[a 1 c]
[a b 1]
[a b c]

func Without 

func Without[T comparable](slice []T, items ...T) []T

Without creates a slice excluding all given items. Play: https://go.dev/play/p/bwhEXEypThg

Example 
result := Without([]int{1, 2, 3, 4}, 1, 2)

fmt.Println(result)

Output:

[3 4]

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.