[Go] maps package

개요

• Documentation
• 모든 유형의 map에 유용한 다양한 함수를 정의
  • All
  • Clone
  • Collect
  • Copy
  • DeleteFunc
  • Equal
  • EqualFunc
  • Insert
  • Keys
  • Values

예제

• 코드

  • package main
           
    import (
        "fmt"
        "maps"
        "strconv"
    )
           
    func All() {
        println("~~~ All start")
        defer println("~~~ All end\n")
           
        m := map[int]string{1: "a", 2: "b"}
        for key, value := range maps.All(m) {
            println(key, ",", value)
        }
    }
           
    func Clone() {
        println("~~~ Clone start")
        defer println("~~~ Clone end\n")
           
        value := "a"
           
        m1 := map[int]*string{1: &value}
        m2 := maps.Clone(m1)
        println(*m1[1], ",", *m2[1])
           
        *m1[1] = "b"
        println(*m1[1], ",", *m2[1])
    }
           
    func Collect() {
        println("~~~ Collect start")
        defer println("~~~ Collect end\n")
           
        seq := maps.All(map[int]string{1: "a", 2: "b"})
        for key, value := range maps.Collect(seq) {
            println(key, ",", value)
        }
    }
           
    func Copy() {
        println("~~~ Copy start")
        defer println("~~~ Copy end\n")
           
        src := map[int]string{1: "a", 2: "b"}
        dst := map[int]string{1: "z", 3: "c"}
           
        maps.Copy(dst, src)
        fmt.Println(dst)
    }
           
    func DeleteFunc() {
        println("~~~ DeleteFunc start")
        defer println("~~~ DeleteFunc end\n")
           
        m := map[int]string{1: "a", 2: "b", 3: "c"}
        del := func(key int, value string) bool {
            return key%2 == 0
        }
           
        maps.DeleteFunc(m, del)
        fmt.Println(m)
    }
           
    func Equal() {
        println("~~~ Equal start")
        defer println("~~~ Equal end\n")
           
        println(maps.Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"}))
        println(maps.Equal(map[int]string{1: "a"}, map[int]string{1: "a", 2: "b"}))
        println(maps.Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "C"}))
        println(maps.Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 3: "b"}))
        println(maps.Equal(map[int]string{1: "a", 2: "b"}, map[int]string{3: "c", 4: "d"}))
    }
           
    func EqualFunc() {
        println("~~~ EqualFunc start")
        defer println("~~~ EqualFunc end\n")
           
        m1 := map[int]int{1: 1, 2: 2}
        m2 := map[int]string{1: "1", 2: "2"}
        eq := func(value1 int, value2 string) bool {
            return strconv.Itoa(value1) == value2
        }
           
        fmt.Println(maps.EqualFunc(m1, m2, eq))
    }
           
    func Insert() {
        println("~~~ Insert start")
        defer println("~~~ Insert end\n")
           
        m := map[int]string{1: "a", 2: "b"}
        fmt.Println(m)
           
        maps.Insert(m, maps.All(map[int]string{3: "c", 4: "d"}))
        fmt.Println(m)
    }
           
    func Keys() {
        println("~~~ Keys start")
        defer println("~~~ Keys end\n")
           
        for key := range maps.Keys(map[int]string{1: "a", 2: "b"}) {
            println(key)
        }
    }
           
    func Values() {
        println("~~~ Values start")
        defer println("~~~ Values end\n")
           
        for value := range maps.Values(map[int]string{1: "a", 2: "b"}) {
            println(value)
        }
    }
           
    func main() {
        All()
        Clone()
        Collect()
        Copy()
        DeleteFunc()
        Equal()
        EqualFunc()
        Insert()
        Keys()
        Values()
    }
    

• 실행 결과

  • ~~~ All start
    1 , a
    2 , b
    ~~~ All end
           
    ~~~ Clone start
    a , a
    b , b
    ~~~ Clone end
           
    ~~~ Collect start
    1 , a
    2 , b
    ~~~ Collect end
           
    ~~~ Copy start
    map[1:a 2:b 3:c]
    ~~~ Copy end
           
    ~~~ DeleteFunc start
    map[1:a 3:c]
    ~~~ DeleteFunc end
           
    ~~~ Equal start
    true
    false
    false
    false
    false
    ~~~ Equal end
           
    ~~~ EqualFunc start
    true
    ~~~ EqualFunc end
           
    ~~~ Insert start
    map[1:a 2:b]
    map[1:a 2:b 3:c 4:d]
    ~~~ Insert end
           
    ~~~ Keys start
    1
    2
    ~~~ Keys end
           
    ~~~ Values start
    a
    b
    ~~~ Values end