Movatterモバイル変換

[0]ホーム
URL:

slices

packagestandard library
go1.25.5Latest Latest
Warning

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

Go to latest Published: Dec 2, 2025 License:BSD-3-ClauseImports:4Imported by:59,822

Details

Repository

cs.opensource.google/go/go

Links

Documentation

Overview

Package slices defines various functions useful with slices of any type.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

funcAlladded ingo1.23.0

func All[Slice ~[]E, Eany](s Slice)iter.Seq2[int, E]

All returns an iterator over index-value pairs in the slicein the usual order.

Example
package mainimport ("fmt""slices")func main() {names := []string{"Alice", "Bob", "Vera"}for i, v := range slices.All(names) {fmt.Println(i, ":", v)}}
Output:0 : Alice1 : Bob2 : Vera

funcAppendSeqadded ingo1.23.0

func AppendSeq[Slice ~[]E, Eany](s Slice, seqiter.Seq[E]) Slice

AppendSeq appends the values from seq to the slice andreturns the extended slice.If seq is empty, the result preserves the nilness of s.

Example
package mainimport ("fmt""slices")func main() {seq := func(yield func(int) bool) {for i := 0; i < 10; i += 2 {if !yield(i) {return}}}s := slices.AppendSeq([]int{1, 2}, seq)fmt.Println(s)}
Output:[1 2 0 2 4 6 8]

funcBackwardadded ingo1.23.0

func Backward[Slice ~[]E, Eany](s Slice)iter.Seq2[int, E]

Backward returns an iterator over index-value pairs in the slice,traversing it backward with descending indices.

Example
package mainimport ("fmt""slices")func main() {names := []string{"Alice", "Bob", "Vera"}for i, v := range slices.Backward(names) {fmt.Println(i, ":", v)}}
Output:2 : Vera1 : Bob0 : Alice

funcBinarySearch

func BinarySearch[S ~[]E, Ecmp.Ordered](x S, target E) (int,bool)

BinarySearch searches for target in a sorted slice and returns the earliestposition where target is found, or the position where target would appearin the sort order; it also returns a bool saying whether the target isreally found in the slice. The slice must be sorted in increasing order.

Example
package mainimport ("fmt""slices")func main() {names := []string{"Alice", "Bob", "Vera"}n, found := slices.BinarySearch(names, "Vera")fmt.Println("Vera:", n, found)n, found = slices.BinarySearch(names, "Bill")fmt.Println("Bill:", n, found)}
Output:Vera: 2 trueBill: 1 false

funcBinarySearchFunc

func BinarySearchFunc[S ~[]E, E, Tany](x S, target T, cmp func(E, T)int) (int,bool)

BinarySearchFunc works likeBinarySearch, but uses a custom comparisonfunction. The slice must be sorted in increasing order, where "increasing"is defined by cmp. cmp should return 0 if the slice element matchesthe target, a negative number if the slice element precedes the target,or a positive number if the slice element follows the target.cmp must implement the same ordering as the slice, such that ifcmp(a, t) < 0 and cmp(b, t) >= 0, then a must precede b in the slice.

Example
package mainimport ("fmt""slices""strings")func main() {type Person struct {Name stringAge  int}people := []Person{{"Alice", 55},{"Bob", 24},{"Gopher", 13},}n, found := slices.BinarySearchFunc(people, Person{"Bob", 0}, func(a, b Person) int {return strings.Compare(a.Name, b.Name)})fmt.Println("Bob:", n, found)}
Output:Bob: 1 true

funcChunkadded ingo1.23.0

func Chunk[Slice ~[]E, Eany](s Slice, nint)iter.Seq[Slice]

Chunk returns an iterator over consecutive sub-slices of up to n elements of s.All but the last sub-slice will have size n.All sub-slices are clipped to have no capacity beyond the length.If s is empty, the sequence is empty: there is no empty slice in the sequence.Chunk panics if n is less than 1.

Example
package mainimport ("fmt""slices")func main() {type Person struct {Name stringAge  int}type People []Personpeople := People{{"Gopher", 13},{"Alice", 20},{"Bob", 5},{"Vera", 24},{"Zac", 15},}// Chunk people into []Person 2 elements at a time.for c := range slices.Chunk(people, 2) {fmt.Println(c)}}
Output:[{Gopher 13} {Alice 20}][{Bob 5} {Vera 24}][{Zac 15}]

funcClip

func Clip[S ~[]E, Eany](s S) S

Clip removes unused capacity from the slice, returning s[:len(s):len(s)].The result preserves the nilness of s.

Example
package mainimport ("fmt""slices")func main() {a := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}s := a[:4:10]clip := slices.Clip(s)fmt.Println(cap(s))fmt.Println(clip)fmt.Println(len(clip))fmt.Println(cap(clip))}
Output:10[0 1 2 3]44

funcClone

func Clone[S ~[]E, Eany](s S) S

Clone returns a copy of the slice.The elements are copied using assignment, so this is a shallow clone.The result may have additional unused capacity.The result preserves the nilness of s.

Example
package mainimport ("fmt""slices")func main() {numbers := []int{0, 42, -10, 8}clone := slices.Clone(numbers)fmt.Println(clone)clone[2] = 10fmt.Println(numbers)fmt.Println(clone)}
Output:[0 42 -10 8][0 42 -10 8][0 42 10 8]

funcCollectadded ingo1.23.0

func Collect[Eany](seqiter.Seq[E]) []E

Collect collects values from seq into a new slice and returns it.If seq is empty, the result is nil.

Example
package mainimport ("fmt""slices")func main() {seq := func(yield func(int) bool) {for i := 0; i < 10; i += 2 {if !yield(i) {return}}}s := slices.Collect(seq)fmt.Println(s)}
Output:[0 2 4 6 8]

funcCompact

func Compact[S ~[]E, Ecomparable](s S) S

Compact replaces consecutive runs of equal elements with a single copy.This is like the uniq command found on Unix.Compact modifies the contents of the slice s and returns the modified slice,which may have a smaller length.Compact zeroes the elements between the new length and the original length.The result preserves the nilness of s.

Example
package mainimport ("fmt""slices")func main() {seq := []int{0, 1, 1, 2, 3, 5, 8}seq = slices.Compact(seq)fmt.Println(seq)}
Output:[0 1 2 3 5 8]

funcCompactFunc

func CompactFunc[S ~[]E, Eany](s S, eq func(E, E)bool) S

CompactFunc is likeCompact but uses an equality function to compare elements.For runs of elements that compare equal, CompactFunc keeps the first one.CompactFunc zeroes the elements between the new length and the original length.The result preserves the nilness of s.

Example
package mainimport ("fmt""slices""strings")func main() {names := []string{"bob", "Bob", "alice", "Vera", "VERA"}names = slices.CompactFunc(names, strings.EqualFold)fmt.Println(names)}
Output:[bob alice Vera]

funcCompare

func Compare[S ~[]E, Ecmp.Ordered](s1, s2 S)int

Compare compares the elements of s1 and s2, usingcmp.Compare on each pairof elements. The elements are compared sequentially, starting at index 0,until one element is not equal to the other.The result of comparing the first non-matching elements is returned.If both slices are equal until one of them ends, the shorter slice isconsidered less than the longer one.The result is 0 if s1 == s2, -1 if s1 < s2, and +1 if s1 > s2.

Example
package mainimport ("fmt""slices")func main() {names := []string{"Alice", "Bob", "Vera"}fmt.Println("Equal:", slices.Compare(names, []string{"Alice", "Bob", "Vera"}))fmt.Println("V < X:", slices.Compare(names, []string{"Alice", "Bob", "Xena"}))fmt.Println("V > C:", slices.Compare(names, []string{"Alice", "Bob", "Cat"}))fmt.Println("3 > 2:", slices.Compare(names, []string{"Alice", "Bob"}))}
Output:Equal: 0V < X: -1V > C: 13 > 2: 1

funcCompareFunc

func CompareFunc[S1 ~[]E1, S2 ~[]E2, E1, E2any](s1 S1, s2 S2, cmp func(E1, E2)int)int

CompareFunc is likeCompare but uses a custom comparison function on eachpair of elements.The result is the first non-zero result of cmp; if cmp alwaysreturns 0 the result is 0 if len(s1) == len(s2), -1 if len(s1) < len(s2),and +1 if len(s1) > len(s2).

Example
package mainimport ("cmp""fmt""slices""strconv")func main() {numbers := []int{0, 43, 8}strings := []string{"0", "0", "8"}result := slices.CompareFunc(numbers, strings, func(n int, s string) int {sn, err := strconv.Atoi(s)if err != nil {return 1}return cmp.Compare(n, sn)})fmt.Println(result)}
Output:1

funcConcatadded ingo1.22.0

func Concat[S ~[]E, Eany](slices ...S) S

Concat returns a new slice concatenating the passed in slices.If the concatenation is empty, the result is nil.

Example
package mainimport ("fmt""slices")func main() {s1 := []int{0, 1, 2, 3}s2 := []int{4, 5, 6}concat := slices.Concat(s1, s2)fmt.Println(concat)}
Output:[0 1 2 3 4 5 6]

funcContains

func Contains[S ~[]E, Ecomparable](s S, v E)bool

Contains reports whether v is present in s.

Example
package mainimport ("fmt""slices")func main() {numbers := []int{0, 1, 2, 3}fmt.Println(slices.Contains(numbers, 2))fmt.Println(slices.Contains(numbers, 4))}
Output:truefalse

funcContainsFunc

func ContainsFunc[S ~[]E, Eany](s S, f func(E)bool)bool

ContainsFunc reports whether at least oneelement e of s satisfies f(e).

Example
package mainimport ("fmt""slices")func main() {numbers := []int{0, 42, -10, 8}hasNegative := slices.ContainsFunc(numbers, func(n int) bool {return n < 0})fmt.Println("Has a negative:", hasNegative)hasOdd := slices.ContainsFunc(numbers, func(n int) bool {return n%2 != 0})fmt.Println("Has an odd number:", hasOdd)}
Output:Has a negative: trueHas an odd number: false

funcDelete

func Delete[S ~[]E, Eany](s S, i, jint) S

Delete removes the elements s[i:j] from s, returning the modified slice.Delete panics if j > len(s) or s[i:j] is not a valid slice of s.Delete is O(len(s)-i), so if many items must be deleted, it is better tomake a single call deleting them all together than to delete one at a time.Delete zeroes the elements s[len(s)-(j-i):len(s)].If the result is empty, it has the same nilness as s.

Example
package mainimport ("fmt""slices")func main() {letters := []string{"a", "b", "c", "d", "e"}letters = slices.Delete(letters, 1, 4)fmt.Println(letters)}
Output:[a e]

funcDeleteFunc

func DeleteFunc[S ~[]E, Eany](s S, del func(E)bool) S

DeleteFunc removes any elements from s for which del returns true,returning the modified slice.DeleteFunc zeroes the elements between the new length and the original length.If the result is empty, it has the same nilness as s.

Example
package mainimport ("fmt""slices")func main() {seq := []int{0, 1, 1, 2, 3, 5, 8}seq = slices.DeleteFunc(seq, func(n int) bool {return n%2 != 0 // delete the odd numbers})fmt.Println(seq)}
Output:[0 2 8]

funcEqual

func Equal[S ~[]E, Ecomparable](s1, s2 S)bool

Equal reports whether two slices are equal: the same length and allelements equal. If the lengths are different, Equal returns false.Otherwise, the elements are compared in increasing index order, and thecomparison stops at the first unequal pair.Empty and nil slices are considered equal.Floating point NaNs are not considered equal.

Example
package mainimport ("fmt""slices")func main() {numbers := []int{0, 42, 8}fmt.Println(slices.Equal(numbers, []int{0, 42, 8}))fmt.Println(slices.Equal(numbers, []int{10}))}
Output:truefalse

funcEqualFunc

func EqualFunc[S1 ~[]E1, S2 ~[]E2, E1, E2any](s1 S1, s2 S2, eq func(E1, E2)bool)bool

EqualFunc reports whether two slices are equal using an equalityfunction on each pair of elements. If the lengths are different,EqualFunc returns false. Otherwise, the elements are compared inincreasing index order, and the comparison stops at the first indexfor which eq returns false.

Example
package mainimport ("fmt""slices""strconv")func main() {numbers := []int{0, 42, 8}strings := []string{"000", "42", "0o10"}equal := slices.EqualFunc(numbers, strings, func(n int, s string) bool {sn, err := strconv.ParseInt(s, 0, 64)if err != nil {return false}return n == int(sn)})fmt.Println(equal)}
Output:true

funcGrow

func Grow[S ~[]E, Eany](s S, nint) S

Grow increases the slice's capacity, if necessary, to guarantee space foranother n elements. After Grow(n), at least n elements can be appendedto the slice without another allocation. If n is negative or too large toallocate the memory, Grow panics.The result preserves the nilness of s.

Example
package mainimport ("fmt""slices")func main() {numbers := []int{0, 42, -10, 8}grow := slices.Grow(numbers, 2)fmt.Println(cap(numbers))fmt.Println(grow)fmt.Println(len(grow))fmt.Println(cap(grow))}
Output:4[0 42 -10 8]48

funcIndex

func Index[S ~[]E, Ecomparable](s S, v E)int

Index returns the index of the first occurrence of v in s,or -1 if not present.

Example
package mainimport ("fmt""slices")func main() {numbers := []int{0, 42, 8}fmt.Println(slices.Index(numbers, 8))fmt.Println(slices.Index(numbers, 7))}
Output:2-1

funcIndexFunc

func IndexFunc[S ~[]E, Eany](s S, f func(E)bool)int

IndexFunc returns the first index i satisfying f(s[i]),or -1 if none do.

Example
package mainimport ("fmt""slices")func main() {numbers := []int{0, 42, -10, 8}i := slices.IndexFunc(numbers, func(n int) bool {return n < 0})fmt.Println("First negative at index", i)}
Output:First negative at index 2

funcInsert

func Insert[S ~[]E, Eany](s S, iint, v ...E) S

Insert inserts the values v... into s at index i,returning the modified slice.The elements at s[i:] are shifted up to make room.In the returned slice r, r[i] == v[0],and, if i < len(s), r[i+len(v)] == value originally at r[i].Insert panics if i > len(s).This function is O(len(s) + len(v)).If the result is empty, it has the same nilness as s.

Example
package mainimport ("fmt""slices")func main() {names := []string{"Alice", "Bob", "Vera"}names = slices.Insert(names, 1, "Bill", "Billie")names = slices.Insert(names, len(names), "Zac")fmt.Println(names)}
Output:[Alice Bill Billie Bob Vera Zac]

funcIsSorted

func IsSorted[S ~[]E, Ecmp.Ordered](x S)bool

IsSorted reports whether x is sorted in ascending order.

Example
package mainimport ("fmt""slices")func main() {fmt.Println(slices.IsSorted([]string{"Alice", "Bob", "Vera"}))fmt.Println(slices.IsSorted([]int{0, 2, 1}))}
Output:truefalse

funcIsSortedFunc

func IsSortedFunc[S ~[]E, Eany](x S, cmp func(a, b E)int)bool

IsSortedFunc reports whether x is sorted in ascending order, with cmp as thecomparison function as defined bySortFunc.

Example
package mainimport ("fmt""slices""strings")func main() {names := []string{"alice", "Bob", "VERA"}isSortedInsensitive := slices.IsSortedFunc(names, func(a, b string) int {return strings.Compare(strings.ToLower(a), strings.ToLower(b))})fmt.Println(isSortedInsensitive)fmt.Println(slices.IsSorted(names))}
Output:truefalse

funcMax

func Max[S ~[]E, Ecmp.Ordered](x S) E

Max returns the maximal value in x. It panics if x is empty.For floating-point E, Max propagates NaNs (any NaN value in xforces the output to be NaN).

Example
package mainimport ("fmt""slices")func main() {numbers := []int{0, 42, -10, 8}fmt.Println(slices.Max(numbers))}
Output:42

funcMaxFunc

func MaxFunc[S ~[]E, Eany](x S, cmp func(a, b E)int) E

MaxFunc returns the maximal value in x, using cmp to compare elements.It panics if x is empty. If there is more than one maximal elementaccording to the cmp function, MaxFunc returns the first one.

Example
package mainimport ("cmp""fmt""slices")func main() {type Person struct {Name stringAge  int}people := []Person{{"Gopher", 13},{"Alice", 55},{"Vera", 24},{"Bob", 55},}firstOldest := slices.MaxFunc(people, func(a, b Person) int {return cmp.Compare(a.Age, b.Age)})fmt.Println(firstOldest.Name)}
Output:Alice

funcMin

func Min[S ~[]E, Ecmp.Ordered](x S) E

Min returns the minimal value in x. It panics if x is empty.For floating-point numbers, Min propagates NaNs (any NaN value in xforces the output to be NaN).

Example
package mainimport ("fmt""slices")func main() {numbers := []int{0, 42, -10, 8}fmt.Println(slices.Min(numbers))}
Output:-10

funcMinFunc

func MinFunc[S ~[]E, Eany](x S, cmp func(a, b E)int) E

MinFunc returns the minimal value in x, using cmp to compare elements.It panics if x is empty. If there is more than one minimal elementaccording to the cmp function, MinFunc returns the first one.

Example
package mainimport ("cmp""fmt""slices")func main() {type Person struct {Name stringAge  int}people := []Person{{"Gopher", 13},{"Bob", 5},{"Vera", 24},{"Bill", 5},}firstYoungest := slices.MinFunc(people, func(a, b Person) int {return cmp.Compare(a.Age, b.Age)})fmt.Println(firstYoungest.Name)}
Output:Bob

funcRepeatadded ingo1.23.0

func Repeat[S ~[]E, Eany](x S, countint) S

Repeat returns a new slice that repeats the provided slice the given number of times.The result has length and capacity (len(x) * count).The result is never nil.Repeat panics if count is negative or if the result of (len(x) * count)overflows.

Example
package mainimport ("fmt""slices")func main() {numbers := []int{0, 1, 2, 3}repeat := slices.Repeat(numbers, 2)fmt.Println(repeat)}
Output:[0 1 2 3 0 1 2 3]

funcReplace

func Replace[S ~[]E, Eany](s S, i, jint, v ...E) S

Replace replaces the elements s[i:j] by the given v, and returns themodified slice.Replace panics if j > len(s) or s[i:j] is not a valid slice of s.When len(v) < (j-i), Replace zeroes the elements between the new length and the original length.If the result is empty, it has the same nilness as s.

Example
package mainimport ("fmt""slices")func main() {names := []string{"Alice", "Bob", "Vera", "Zac"}names = slices.Replace(names, 1, 3, "Bill", "Billie", "Cat")fmt.Println(names)}
Output:[Alice Bill Billie Cat Zac]

funcReverse

func Reverse[S ~[]E, Eany](s S)

Reverse reverses the elements of the slice in place.

Example
package mainimport ("fmt""slices")func main() {names := []string{"alice", "Bob", "VERA"}slices.Reverse(names)fmt.Println(names)}
Output:[VERA Bob alice]

funcSort

func Sort[S ~[]E, Ecmp.Ordered](x S)

Sort sorts a slice of any ordered type in ascending order.When sorting floating-point numbers, NaNs are ordered before other values.

Example
package mainimport ("fmt""slices")func main() {smallInts := []int8{0, 42, -10, 8}slices.Sort(smallInts)fmt.Println(smallInts)}
Output:[-10 0 8 42]

funcSortFunc

func SortFunc[S ~[]E, Eany](x S, cmp func(a, b E)int)

SortFunc sorts the slice x in ascending order as determined by the cmpfunction. This sort is not guaranteed to be stable.cmp(a, b) should return a negative number when a < b, a positive number whena > b and zero when a == b or a and b are incomparable in the sense ofa strict weak ordering.

SortFunc requires that cmp is a strict weak ordering.Seehttps://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings.The function should return 0 for incomparable items.

Example (CaseInsensitive)
package mainimport ("fmt""slices""strings")func main() {names := []string{"Bob", "alice", "VERA"}slices.SortFunc(names, func(a, b string) int {return strings.Compare(strings.ToLower(a), strings.ToLower(b))})fmt.Println(names)}
Output:[alice Bob VERA]

Example (MultiField)
package mainimport ("cmp""fmt""slices""strings")func main() {type Person struct {Name stringAge  int}people := []Person{{"Gopher", 13},{"Alice", 55},{"Bob", 24},{"Alice", 20},}slices.SortFunc(people, func(a, b Person) int {if n := strings.Compare(a.Name, b.Name); n != 0 {return n}// If names are equal, order by agereturn cmp.Compare(a.Age, b.Age)})fmt.Println(people)}
Output:[{Alice 20} {Alice 55} {Bob 24} {Gopher 13}]

funcSortStableFunc

func SortStableFunc[S ~[]E, Eany](x S, cmp func(a, b E)int)

SortStableFunc sorts the slice x while keeping the original order of equalelements, using cmp to compare elements in the same way asSortFunc.

Example
package mainimport ("fmt""slices""strings")func main() {type Person struct {Name stringAge  int}people := []Person{{"Gopher", 13},{"Alice", 20},{"Bob", 24},{"Alice", 55},}// Stable sort by name, keeping age ordering of Alice intactslices.SortStableFunc(people, func(a, b Person) int {return strings.Compare(a.Name, b.Name)})fmt.Println(people)}
Output:[{Alice 20} {Alice 55} {Bob 24} {Gopher 13}]

funcSortedadded ingo1.23.0

func Sorted[Ecmp.Ordered](seqiter.Seq[E]) []E

Sorted collects values from seq into a new slice, sorts the slice,and returns it.If seq is empty, the result is nil.

Example
package mainimport ("fmt""slices")func main() {seq := func(yield func(int) bool) {flag := -1for i := 0; i < 10; i += 2 {flag = -flagif !yield(i * flag) {return}}}s := slices.Sorted(seq)fmt.Println(s)fmt.Println(slices.IsSorted(s))}
Output:[-6 -2 0 4 8]true

funcSortedFuncadded ingo1.23.0

func SortedFunc[Eany](seqiter.Seq[E], cmp func(E, E)int) []E

SortedFunc collects values from seq into a new slice, sorts the sliceusing the comparison function, and returns it.If seq is empty, the result is nil.

Example
package mainimport ("cmp""fmt""slices")func main() {seq := func(yield func(int) bool) {flag := -1for i := 0; i < 10; i += 2 {flag = -flagif !yield(i * flag) {return}}}sortFunc := func(a, b int) int {return cmp.Compare(b, a) // the comparison is being done in reverse}s := slices.SortedFunc(seq, sortFunc)fmt.Println(s)}
Output:[8 4 0 -2 -6]

funcSortedStableFuncadded ingo1.23.0

func SortedStableFunc[Eany](seqiter.Seq[E], cmp func(E, E)int) []E

SortedStableFunc collects values from seq into a new slice.It then sorts the slice while keeping the original order of equal elements,using the comparison function to compare elements.It returns the new slice.If seq is empty, the result is nil.

Example
package mainimport ("cmp""fmt""slices")func main() {type Person struct {Name stringAge  int}people := []Person{{"Gopher", 13},{"Alice", 20},{"Bob", 5},{"Vera", 24},{"Zac", 20},}sortFunc := func(x, y Person) int {return cmp.Compare(x.Age, y.Age)}s := slices.SortedStableFunc(slices.Values(people), sortFunc)fmt.Println(s)}
Output:[{Bob 5} {Gopher 13} {Alice 20} {Zac 20} {Vera 24}]

funcValuesadded ingo1.23.0

func Values[Slice ~[]E, Eany](s Slice)iter.Seq[E]

Values returns an iterator that yields the slice elements in order.

Example
package mainimport ("fmt""slices")func main() {names := []string{"Alice", "Bob", "Vera"}for v := range slices.Values(names) {fmt.Println(v)}}
Output:AliceBobVera

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f orF : Jump to
y orY : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic.Learn more.
[8]ページ先頭
©2009-2025 Movatter.jp