[Go] slices package

개요

• Documentation
• 모든 유형의 슬라이스에 유용한 다양한 함수를 정의
  • All
  • AppendSeq
  • Backward
  • BinarySearch
  • BinarySearchFunc
  • Chunk
  • Clip
  • Clone
  • Collect
  • Compact
  • CompactFunc
  • Compare
  • CompareFunc
  • Concat
  • Contains
  • ContainsFunc
  • Delete
  • DeleteFunc
  • Equal
  • EqualFunc
  • Grow
  • Index
  • IndexFunc
  • Insert
  • IsSorted
  • IsSortedFunc
  • Max
  • MaxFunc
  • Min
  • MinFunc
  • Repeat
  • Replace
  • Reverse
  • Sort
  • SortFunc
  • SortStableFunc
  • Sorted
  • SortedFunc
  • SortedStableFunc
  • Values

예제

• 코드

  • package main
           
    import (
        "cmp"
        "fmt"
        "slices"
        "strconv"
        "strings"
    )
           
    func All() {
        println("~~~ All start")
        defer println("~~~ All end\n")
           
        slice := []string{"a", "e", "c"}
           
        for index, value := range slices.All(slice) {
            println(index, ",", value)
        }
    }
           
    func AppendSeq() {
        println("~~~ AppendSeq start")
        defer println("~~~ AppendSeq end\n")
           
        slice := []string{"a", "e", "c"}
           
        for index, value := range slices.AppendSeq(slice, slices.Values([]string{"b", "d"})) {
            println(index, ",", value)
        }
    }
           
    func Backward() {
        println("~~~ Backward start")
        defer println("~~~ Backward end\n")
           
        slice := []string{"a", "e", "c"}
           
        for index, value := range slices.Backward(slice) {
            println(index, ",", value)
        }
    }
           
    func BinarySearch() {
        println("~~~ BinarySearch start")
        defer println("~~~ BinarySearch end\n")
           
        slice := []string{"a", "e", "c"}
        slices.Sort(slice)
        fmt.Println(slice)
           
        println(slices.BinarySearch(slice, "a"))
        println(slices.BinarySearch(slice, "e"))
        println(slices.BinarySearch(slice, "c"))
           
        println(slices.BinarySearch(slice, "b"))
        println(slices.BinarySearch(slice, "d"))
    }
           
    func BinarySearchFunc() {
        println("~~~ BinarySearchFunc start")
        defer println("~~~ BinarySearchFunc end\n")
           
        type T struct {
            i int
            s string
        }
           
        slice := []T{
            {1, "a"},
            {2, "b"},
        }
           
        cmp := func(t1, t2 T) int {
            return strings.Compare(t1.s, t2.s)
        }
           
        println(slices.BinarySearchFunc(slice, T{i: 100, s: "a"}, cmp))
        println(slices.BinarySearchFunc(slice, T{i: 100, s: "b"}, cmp))
        println(slices.BinarySearchFunc(slice, T{i: 100, s: "c"}, cmp))
    }
           
    func Chunk() {
        println("~~~ Chunk start")
        defer println("~~~ Chunk end\n")
           
        for seq := range slices.Chunk([]int{1, 2, 3, 4, 5}, 2) {
            fmt.Println(seq)
        }
    }
           
    func Clip() {
        println("~~~ Clip start")
        defer println("~~~ Clip end\n")
           
        slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}[:5:9]
        fmt.Println(slice, ",", cap(slice))
           
        clip := slices.Clip(slice)
        fmt.Println(clip, ",", cap(clip))
    }
           
    func Clone() {
        println("~~~ Clone start")
        defer println("~~~ Clone end\n")
           
        value := 1
           
        slice := []*int{&value}
        clone := slices.Clone(slice)
        fmt.Println(*slice[0], ",", *clone[0])
           
        *slice[0] = 10
        fmt.Println(*slice[0], ",", *clone[0])
    }
           
    func Collect() {
        println("~~~ Collect start")
        defer println("~~~ Collect end\n")
           
        seq := slices.Values([]int{1, 2, 3, 4, 5})
        fmt.Printf("%T\n", seq)
           
        slice := slices.Collect(seq)
        fmt.Printf("%T\n", slice)
        fmt.Println(slice)
    }
           
    func Compact() {
        println("~~~ Compact start")
        defer println("~~~ Compact end\n")
           
        slice := []int{1, 2, 1, 3, 5, 4, 5}
        fmt.Println(slice)
        fmt.Println(slices.Compact(slice))
           
        println()
           
        slices.Sort(slice)
        fmt.Println(slice)
        fmt.Println(slices.Compact(slice))
    }
           
    func CompactFunc() {
        println("~~~ CompactFunc start")
        defer println("~~~ CompactFunc end\n")
           
        slice := []string{"a", "A", "b", "B", "c", "C"}
        fmt.Println(slices.Compact(slice))
        fmt.Println(slices.CompactFunc(slice, strings.EqualFold))
    }
           
    func Compare() {
        println("~~~ Compare start")
        defer println("~~~ Compare end\n")
           
        slice := []int{1, 2, 3}
           
        println(slices.Compare(slice, []int{1, 2, 3}))
        println(slices.Compare(slice, []int{1, 2}))
        println(slices.Compare(slice, []int{1, 2, 3, 4}))
    }
           
    func CompareFunc() {
        println("~~~ CompareFunc start")
        defer println("~~~ CompareFunc end\n")
           
        slice1 := []int{1, 2, 3}
        slice2 := []string{"1", "2", "3"}
           
        cmp := func(i int, s string) int {
            return cmp.Compare(strconv.Itoa(i), s)
        }
           
        println(slices.CompareFunc(slice1, slice2, cmp))
    }
           
    func Concat() {
        println("~~~ Concat start")
        defer println("~~~ Concat end\n")
           
        fmt.Println(slices.Concat([]int{1, 2, 3}, []int{4, 5, 6}))
    }
           
    func Contains() {
        println("~~~ Contains start")
        defer println("~~~ Contains end\n")
           
        slice := []int{1, 2, 3}
        println(slices.Contains(slice, 2))
        println(slices.Contains(slice, 5))
    }
           
    func ContainsFunc() {
        println("~~~ ContainsFunc start")
        defer println("~~~ ContainsFunc end\n")
           
        println(slices.ContainsFunc([]int{1, 2, 3}, func(i int) bool { return i%2 == 0 }))
    }
           
    func Delete() {
        println("~~~ Delete start")
        defer println("~~~ Delete end\n")
           
        fmt.Println(slices.Delete([]int{1, 2, 3, 4, 5, 6, 7, 8, 9}, 1, 8))
    }
           
    func DeleteFunc() {
        println("~~~ DeleteFunc start")
        defer println("~~~ DeleteFunc end\n")
           
        fmt.Println(slices.DeleteFunc([]int{1, 2, 3, 4, 5}, func(i int) bool { return i%2 == 0 }))
    }
           
    func Equal() {
        println("~~~ Equal start")
        defer println("~~~ Equal end\n")
           
        slice := []int{1, 2, 3}
           
        println(slices.Equal(slice, []int{1, 2, 3}))
        println(slices.Equal(slice, []int{1, 2}))
    }
           
    func EqualFunc() {
        println("~~~ EqualFunc start")
        defer println("~~~ EqualFunc end\n")
           
        eq := func(i int, s string) bool {
            return strconv.Itoa(i) == s
        }
           
        println(slices.EqualFunc([]int{1, 2, 3}, []string{"1", "2", "3"}, eq))
    }
           
    func Grow() {
        println("~~~ Grow start")
        defer println("~~~ Grow end\n")
           
        slice := []int{1, 2, 3}
        fmt.Println(cap(slice))
           
        grow := slices.Grow(slice, 3)
        fmt.Println(cap(grow))
    }
           
    func Index() {
        println("~~~ Index start")
        defer println("~~~ Index end\n")
           
        slice := []string{"a", "b", "c"}
        println(slices.Index(slice, "a"))
        println(slices.Index(slice, "b"))
        println(slices.Index(slice, "c"))
        println(slices.Index(slice, "e"))
    }
           
    func IndexFunc() {
        println("~~~ IndexFunc start")
        defer println("~~~ IndexFunc end\n")
           
        println(slices.IndexFunc([]int{1, 2, 3}, func(i int) bool { return i > 2 }))
    }
           
    func Insert() {
        println("~~~ Insert start")
        defer println("~~~ Insert end\n")
           
        slice := []string{"a", "d"}
           
        fmt.Println(slices.Insert(slice, 1, "b", "c"))
        fmt.Println(slices.Insert(slice, len(slice), "e"))
    }
           
    func IsSorted() {
        println("~~~ IsSorted start")
        defer println("~~~ IsSorted end\n")
           
        println(slices.IsSorted([]int{1, 2, 3}))
        println(slices.IsSorted([]int{1, 3, 2}))
           
        println(slices.IsSorted([]string{"a", "b", "c"}))
        println(slices.IsSorted([]string{"a", "c", "b"}))
    }
           
    func IsSortedFunc() {
        println("~~~ IsSortedFunc start")
        defer println("~~~ IsSortedFunc end\n")
           
        slice := []string{"a", "B", "c"}
        println(slices.IsSorted(slice))
           
        cmp := func(s1, s2 string) int {
            return strings.Compare(strings.ToLower(s1), strings.ToLower(s2))
        }
        println(slices.IsSortedFunc(slice, cmp))
    }
           
    func Max() {
        println("~~~ Max start")
        defer println("~~~ Max end\n")
           
        println(slices.Max([]int{1, 2, 10, 3}))
    }
           
    func MaxFunc() {
        println("~~~ MaxFunc start")
        defer println("~~~ MaxFunc end\n")
           
        slice := []int{1, 2, 3}
        cmp := func(i1, i2 int) int {
            return cmp.Compare(i1*-1, i2*-1)
        }
        println(slices.MaxFunc(slice, cmp))
    }
           
    func Min() {
        println("~~~ Min start")
        defer println("~~~ Min end\n")
           
        println(slices.Min([]int{1, 2, 10, 3}))
    }
           
    func MinFunc() {
        println("~~~ MinFunc start")
        defer println("~~~ MinFunc end\n")
           
        slice := []int{1, 2, 3}
        cmp := func(i1, i2 int) int {
            return cmp.Compare(i1*-1, i2*-1)
        }
        println(slices.MinFunc(slice, cmp))
    }
           
    func Repeat() {
        println("~~~ Repeat start")
        defer println("~~~ Repeat end\n")
           
        fmt.Println(slices.Repeat([]int{1, 2, 3}, 3))
    }
           
    func Replace() {
        println("~~~ Replace start")
        defer println("~~~ Replace end\n")
           
        slice := []string{"a", "y", "z", "e"}
           
        fmt.Println(slices.Replace(slice, 1, 3, "b"))
        fmt.Println(slices.Replace(slice, 1, 3, "b", "c", "d"))
    }
           
    func Reverse() {
        println("~~~ Reverse start")
        defer println("~~~ Reverse end\n")
           
        slice := []int{1, 2, 3}
        slices.Reverse(slice)
        fmt.Println(slice)
    }
           
    func Sort() {
        println("~~~ Sort start")
        defer println("~~~ Sort end\n")
           
        slice := []int{1, 3, 2}
        slices.Sort(slice)
        fmt.Println(slice)
    }
           
    func SortFunc() {
        println("~~~ SortFunc start")
        defer println("~~~ SortFunc end\n")
           
        slice := []int{1, 3, 2}
        cmp := func(i1, i2 int) int {
            return cmp.Compare(i2, i1)
        }
        slices.SortFunc(slice, cmp)
        fmt.Println(slice)
    }
           
    func SortStableFunc() {
        println("~~~ SortStableFunc start")
        defer println("~~~ SortStableFunc end\n")
           
        type T struct {
            i int
            s string
        }
           
        slice := []T{
            {1, "a"},
            {2, "b"},
            {1, "c"},
        }
           
        cmp := func(t1, t2 T) int {
            return cmp.Compare(t1.i, t2.i)
            //return strings.Compare(t1.s, t2.s)
        }
           
        slices.SortStableFunc(slice, cmp)
        fmt.Println(slice)
    }
           
    func Sorted() {
        println("~~~ Sorted start")
        defer println("~~~ Sorted end\n")
           
        seq := slices.Values([]string{"c", "a", "b"})
        fmt.Println(slices.Sorted(seq))
    }
           
    func SortedFunc() {
        println("~~~ SortedFunc start")
        defer println("~~~ SortedFunc end\n")
           
        seq := slices.Values([]string{"c", "a", "b"})
        cmp := func(s1, s2 string) int {
            return strings.Compare(s2, s1)
        }
           
        fmt.Println(slices.SortedFunc(seq, cmp))
    }
           
    func SortedStableFunc() {
        println("~~~ SortedStableFunc start")
        defer println("~~~ SortedStableFunc end\n")
           
        seq := slices.Values([]string{"c", "a", "b"})
        cmp := func(s1, s2 string) int {
            return strings.Compare(s2, s1)
        }
           
        fmt.Println(slices.SortedFunc(seq, cmp))
    }
           
    func Values() {
        println("~~~ Values start")
        defer println("~~~ Values end\n")
           
        for value := range slices.Values([]string{"c", "a", "b"}) {
            println(value)
        }
    }
           
    func main() {
        All()
        AppendSeq()
        Backward()
        BinarySearch()
        BinarySearchFunc()
        Chunk()
        Clip()
        Clone()
        Collect()
        Compact()
        CompactFunc()
        Compare()
        CompareFunc()
        Concat()
        Contains()
        ContainsFunc()
        Delete()
        DeleteFunc()
        Equal()
        EqualFunc()
        Grow()
        Index()
        IndexFunc()
        Insert()
        IsSorted()
        IsSortedFunc()
        Max()
        MaxFunc()
        Min()
        MinFunc()
        Repeat()
        Replace()
        Reverse()
        Sort()
        SortFunc()
        SortStableFunc()
        Sorted()
        SortedFunc()
        SortedStableFunc()
        Values()
    }
    

• 실행 결과

  • ~~~ All start
    0 , a
    1 , e
    2 , c
    ~~~ All end
           
    ~~~ AppendSeq start
    0 , a
    1 , e
    2 , c
    3 , b
    4 , d
    ~~~ AppendSeq end
           
    ~~~ Backward start
    2 , c
    1 , e
    0 , a
    ~~~ Backward end
           
    ~~~ BinarySearch start
    [a c e]
    0 true
    2 true
    1 true
    1 false
    2 false
    ~~~ BinarySearch end
           
    ~~~ BinarySearchFunc start
    0 true
    1 true
    2 false
    ~~~ BinarySearchFunc end
           
    ~~~ Chunk start
    [1 2]
    [3 4]
    [5]
    ~~~ Chunk end
           
    ~~~ Clip start
    [1 2 3 4 5] , 9
    [1 2 3 4 5] , 5
    ~~~ Clip end
           
    ~~~ Clone start
    1 , 1
    10 , 10
    ~~~ Clone end
           
    ~~~ Collect start
    iter.Seq[int]
    []int
    [1 2 3 4 5]
    ~~~ Collect end
           
    ~~~ Compact start
    [1 2 1 3 5 4 5]
    [1 2 1 3 5 4 5]
           
    [1 1 2 3 4 5 5]
    [1 2 3 4 5]
    ~~~ Compact end
           
    ~~~ CompactFunc start
    [a A b B c C]
    [a b c]
    ~~~ CompactFunc end
           
    ~~~ Compare start
    0
    1
    -1
    ~~~ Compare end
           
    ~~~ CompareFunc start
    0
    ~~~ CompareFunc end
           
    ~~~ Concat start
    [1 2 3 4 5 6]
    ~~~ Concat end
           
    ~~~ Contains start
    true
    false
    ~~~ Contains end
           
    ~~~ ContainsFunc start
    true
    ~~~ ContainsFunc end
           
    ~~~ Delete start
    [1 9]
    ~~~ Delete end
           
    ~~~ DeleteFunc start
    [1 3 5]
    ~~~ DeleteFunc end
           
    ~~~ Equal start
    true
    false
    ~~~ Equal end
           
    ~~~ EqualFunc start
    true
    ~~~ EqualFunc end
           
    ~~~ Grow start
    3
    6
    ~~~ Grow end
           
    ~~~ Index start
    0
    1
    2
    -1
    ~~~ Index end
           
    ~~~ IndexFunc start
    2
    ~~~ IndexFunc end
           
    ~~~ Insert start
    [a b c d]
    [a d e]
    ~~~ Insert end
           
    ~~~ IsSorted start
    true
    false
    true
    false
    ~~~ IsSorted end
           
    ~~~ IsSortedFunc start
    false
    true
    ~~~ IsSortedFunc end
           
    ~~~ Max start
    10
    ~~~ Max end
           
    ~~~ MaxFunc start
    1
    ~~~ MaxFunc end
           
    ~~~ Min start
    1
    ~~~ Min end
           
    ~~~ MinFunc start
    3
    ~~~ MinFunc end
           
    ~~~ Repeat start
    [1 2 3 1 2 3 1 2 3]
    ~~~ Repeat end
           
    ~~~ Replace start
    [a b e]
    [a b c d ]
    ~~~ Replace end
           
    ~~~ Reverse start
    [3 2 1]
    ~~~ Reverse end
           
    ~~~ Sort start
    [1 2 3]
    ~~~ Sort end
           
    ~~~ SortFunc start
    [3 2 1]
    ~~~ SortFunc end
           
    ~~~ SortStableFunc start
    [{1 a} {1 c} {2 b}]
    ~~~ SortStableFunc end
           
    ~~~ Sorted start
    [a b c]
    ~~~ Sorted end
           
    ~~~ SortedFunc start
    [c b a]
    ~~~ SortedFunc end
           
    ~~~ SortedStableFunc start
    [c b a]
    ~~~ SortedStableFunc end
           
    ~~~ Values start
    c
    a
    b
    ~~~ Values end