slices

package
v1.21.10 Latest Latest
Warning

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

 Go to latest Published: Feb 7, 2024 License: MIT Imports: 1 Imported by: 0

Documentation

Overview

slices パッケージは、任意の型のスライスで使用できるさまざまな関数を定義します。

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func BinarySearch 

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

BinarySearch は、ソートされたスライス内で target を検索し、target が見つかる位置、 またはソート順序で target が表示される位置を返します。 また、スライス内に target が本当に見つかったかどうかを示す bool も返します。 スライスは昇順にソートする必要があります。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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 true
Bill: 1 false

func BinarySearchFunc 

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

BinarySearchFunc は、カスタム比較関数を使用して BinarySearch と同様に動作します。 スライスは、cmp によって定義される増加順でソートする必要があります。 cmp は、スライス要素がターゲットに一致する場合は 0、スライス要素がターゲットよりも前の場合は負の数、 スライス要素がターゲットよりも後ろの場合は正の数を返す必要があります。 cmp は、スライスと同じ順序付けを実装する必要があります。つまり、 cmp(a, t) < 0 かつ cmp(b, t) >= 0 の場合、a はスライス内で b よりも前になければなりません。

Example 
package main

import (
	"github.com/shogo82148/std/cmp"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

func main() {
	type Person struct {
		Name string
		Age  int
	}
	people := []Person{
		{"Alice", 55},
		{"Bob", 24},
		{"Gopher", 13},
	}
	n, found := slices.BinarySearchFunc(people, Person{"Bob", 0}, func(a, b Person) int {
		return cmp.Compare(a.Name, b.Name)
	})
	fmt.Println("Bob:", n, found)
}

Output:

Bob: 1 true

func Clip 

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

Clip は、スライスから未使用の容量を削除し、s[:len(s):len(s)] を返します。

func Clone 

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

Clone は、スライスのコピーを返します。 要素は代入を使用してコピーされるため、これは浅いクローンです。

func Compact 

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

Compact は、等しい要素の連続したランを単一のコピーに置き換えます。 これは、Unix で見つかる uniq コマンドのようです。 Compact はスライス s の内容を変更し、変更されたスライスを返します。 変更されたスライスの長さが短くなる場合があります。 Compact が合計で m 個の要素を破棄すると、s[len(s)-m:len(s)] の要素を変更しない場合があります。 これらの要素にポインタが含まれている場合は、参照するオブジェクトをガベージコレクションできるように、 これらの要素をゼロにすることを検討する必要があります。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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]

func CompactFunc 

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

CompactFunc は、等価性関数を使用して要素を比較する Compact です。 等しい要素のランに対して、CompactFunc は最初の要素を保持します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
	"github.com/shogo82148/std/strings"
)

func main() {
	names := []string{"bob", "Bob", "alice", "Vera", "VERA"}
	names = slices.CompactFunc(names, func(a, b string) bool {
		return strings.ToLower(a) == strings.ToLower(b)
	})
	fmt.Println(names)
}

Output:

[bob alice Vera]

func Compare 

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

Compare は、s1 と s2 の要素を、各ペアで cmp.Compare を使用して比較します。 要素は、インデックス 0 から順番に比較され、一方の要素が他方と等しくなくなるまで比較が続けられます。 最初の不一致要素の比較結果が返されます。 どちらかのスライスが終端に達するまで、両方のスライスが等しい場合、短いスライスが長いスライスよりも小さいと見なされます。 結果は、s1 == s2 の場合は 0、s1 < s2 の場合は -1、s1 > s2 の場合は +1 です。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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: 0
V < X: -1
V > C: 1
3 > 2: 1

func CompareFunc 

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

CompareFunc は、各要素のペアに対してカスタム比較関数を使用して s1 と s2 の要素を比較します。 結果は、cmp の最初の非ゼロ結果です。cmp が常に 0 を返す場合、結果は len(s1) == len(s2) の場合は 0、len(s1) < len(s2) の場合は -1、len(s1) > len(s2) の場合は +1 です。

Example 
package main

import (
	"github.com/shogo82148/std/cmp"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
	"github.com/shogo82148/std/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

func Contains 

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

Contains は、s 内に v が存在するかどうかを報告します。

func ContainsFunc 

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

ContainsFunc は、s の少なくとも1つの要素 e が f(e) を満たすかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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: true
Has an odd number: false

func Delete 

func Delete[S ~[]E, E any](s S, i, j int) S

Delete は、s[i:j] の要素を削除し、変更されたスライスを返します。 s[i:j] が s の有効なスライスでない場合、Delete は panic を発生させます。 Delete は O(len(s)-j) であり、多数のアイテムを削除する必要がある場合は、 1つずつ削除するよりも、まとめて削除する単一の呼び出しを作成する方が良いです。 Delete は、s[len(s)-(j-i):len(s)] の要素を変更しない場合があります。 これらの要素にポインタが含まれている場合は、参照するオブジェクトをガベージコレクションできるように、 これらの要素をゼロにすることを検討する必要があります。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

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

Output:

[a e]

func DeleteFunc 

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

DeleteFunc は、del が true を返す要素を s から削除し、変更されたスライスを返します。 DeleteFunc が m 個の要素を削除すると、s[len(s)-m:len(s)] の要素を変更しない場合があります。 これらの要素にポインタが含まれている場合は、参照するオブジェクトをガベージコレクションできるように、 これらの要素をゼロにすることを検討する必要があります。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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]

func Equal 

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

Equal は、2つのスライスが等しいかどうかを報告します。 長さが異なる場合、Equal は false を返します。 そうでない場合、要素はインデックスの昇順で比較され、比較は最初の異なるペアで停止します。 浮動小数点 NaN は等しくないと見なされます。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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:

true
false

func EqualFunc 

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

EqualFunc は、各要素のペアに対して等値性関数を使用して2つのスライスが等しいかどうかを報告します。 長さが異なる場合、EqualFunc は false を返します。 そうでない場合、要素はインデックスの昇順で比較され、比較は最初の異なるペアで停止します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
	"github.com/shogo82148/std/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

func Grow 

func Grow[S ~[]E, E any](s S, n int) S

Grow は、必要に応じてスライスの容量を増やし、別の n 要素のスペースを保証します。 Grow(n) の後、スライスには、別の割り当てなしで n 要素が追加できます。 n が負の場合、またはメモリを割り当てるには大きすぎる場合、Grow は panic を発生させます。

func Index 

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

Index は、s 内で最初に v が出現するインデックスを返します。 v が存在しない場合は -1 を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

func main() {
	numbers := []int{0, 42, 8}
	fmt.Println(slices.Index(numbers, 8))
	fmt.Println(slices.Index(numbers, 7))
}

Output:

2
-1

func IndexFunc 

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

IndexFunc は、f(s[i]) を満たす最初のインデックス i を返します。 そのようなインデックスが存在しない場合は -1 を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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

func Insert 

func Insert[S ~[]E, E any](s S, i int, v ...E) S

Insert は、値 v... を s のインデックス i に挿入し、変更されたスライスを返します。 s[i:] の要素は上にシフトされ、スペースが作成されます。 返されるスライス r では、r[i] == v[0] であり、r[i+len(v)] == r[i] に元々あった値です。 i が範囲外の場合、Insert は panic を発生させます。 この関数の計算量は O(len(s) + len(v)) です。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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]

func IsSorted 

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

IsSorted は、x が昇順にソートされているかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

func main() {
	fmt.Println(slices.IsSorted([]string{"Alice", "Bob", "Vera"}))
	fmt.Println(slices.IsSorted([]int{0, 2, 1}))
}

Output:

true
false

func IsSortedFunc 

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

IsSortedFunc は、x が昇順にソートされているかどうかを報告します。 このソートは、cmp 関数によって定義された比較関数によって行われます。

Example 
package main

import (
	"github.com/shogo82148/std/cmp"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
	"github.com/shogo82148/std/strings"
)

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

Output:

true
false

func Max 

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

Max は、x 内の最大値を返します。x が空の場合は panic を発生させます。 浮動小数点数の場合、Max は NaN を伝播します（x 内の任意の NaN 値は、出力を NaN にします）。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

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

Output:

42

func MaxFunc 

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

MaxFunc は、cmp 関数によって比較された x 内の最大値を返します。 x が空の場合、MaxFunc は panic を発生させます。 cmp 関数によって複数の最大要素がある場合、MaxFunc は最初の要素を返します。

Example 
package main

import (
	"github.com/shogo82148/std/cmp"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

func main() {
	type Person struct {
		Name string
		Age  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

func Min 

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

Min は、x 内の最小値を返します。x が空の場合は panic を発生させます。 浮動小数点数の場合、Min は NaN を伝播します（x 内の任意の NaN 値は、出力を NaN にします）。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

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

Output:

-10

func MinFunc 

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

MinFunc は、cmp 関数によって比較された x 内の最小値を返します。 x が空の場合、MinFunc は panic を発生させます。 cmp 関数によって複数の最小要素がある場合、MinFunc は最初の要素を返します。

Example 
package main

import (
	"github.com/shogo82148/std/cmp"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

func main() {
	type Person struct {
		Name string
		Age  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

func Replace 

func Replace[S ~[]E, E any](s S, i, j int, v ...E) S

Replace は、s[i:j] の要素を与えられた v で置き換え、変更されたスライスを返します。 s[i:j] が s の有効なスライスでない場合、Replace は panic を発生させます。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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]

func Reverse 

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

Reverse は、スライスの要素を逆順にします。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

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

Output:

[VERA Bob alice]

func Sort 

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

Sort は、任意の順序付け可能な型のスライスを昇順にソートします。 浮動小数点数をソートする場合、NaN は他の値の前に並べられます。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

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

Output:

[-10 0 8 42]

func SortFunc 

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

SortFunc は、cmp 関数によって決定される昇順でスライス x をソートします。 このソートは安定であることは保証されません。 cmp(a, b) は、a < b の場合は負の数、a > b の場合は正の数、a == b の場合はゼロを返す必要があります。

SortFunc は、cmp が厳密な弱順序であることを要求します。 https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings を参照してください。

Example (CaseInsensitive) 
package main

import (
	"github.com/shogo82148/std/cmp"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
	"github.com/shogo82148/std/strings"
)

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

Output:

[alice Bob VERA]
Example (MultiField) 
package main

import (
	"github.com/shogo82148/std/cmp"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

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

Output:

[{Alice 20} {Alice 55} {Bob 24} {Gopher 13}]

func SortStableFunc 

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

SortStableFunc は、cmp 関数によって決定される順序でスライス x をソートします。 このソートは安定であり、等しい要素の元の順序を維持します。 cmp(a, b) は、a < b の場合は負の数、a > b の場合は正の数、a == b の場合はゼロを返す必要があります。

SortStableFunc は、cmp が厳密な弱順序であることを要求します。 https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings を参照してください。

Example 
package main

import (
	"github.com/shogo82148/std/cmp"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/slices"
)

func main() {
	type Person struct {
		Name string
		Age  int
	}
	people := []Person{
		{"Gopher", 13},
		{"Alice", 20},
		{"Bob", 24},
		{"Alice", 55},
	}
	// Stable sort by name, keeping age ordering of Alices intact
	slices.SortStableFunc(people, func(a, b Person) int {
		return cmp.Compare(a.Name, b.Name)
	})
	fmt.Println(people)
}

Output:

[{Alice 20} {Alice 55} {Bob 24} {Gopher 13}]

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.