maputil

package
v2.2.0 Latest Latest
Warning

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

 Go to latest Published: May 18, 2023 License: MIT Imports: 4 Imported by: 42

Documentation

Overview

Package maputil includes some functions to manipulate map.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Filter 

func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V

Filter iterates over map, return a new map contains all key and value pairs pass the predicate function. Play: https://go.dev/play/p/fSvF3wxuNG7

Example 
m := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
	"d": 4,
	"e": 5,
}

isEven := func(_ string, value int) bool {
	return value%2 == 0
}

result := Filter(m, isEven)

fmt.Println(result)

Output:

map[b:2 d:4]

func FilterByKeys added in v2.1.16 

func FilterByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V

FilterByKeys iterates over map, return a new map whose keys are all given keys. Play: https://go.dev/play/p/7ov6BJHbVqh

Example 
m := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
	"d": 4,
	"e": 5,
}

result := FilterByKeys(m, []string{"a", "b"})

fmt.Println(result)

Output:

map[a:1 b:2]

func FilterByValues added in v2.1.16 

func FilterByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V

FilterByValues iterates over map, return a new map whose values are all given values. Play: https://go.dev/play/p/P3-9MdcXegR

Example 
m := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
	"d": 4,
	"e": 5,
}

result := FilterByValues(m, []int{3, 4})

fmt.Println(result)

Output:

map[c:3 d:4]

func ForEach 

func ForEach[K comparable, V any](m map[K]V, iteratee func(key K, value V))

ForEach executes iteratee funcation for every key and value pair in map. Play: https://go.dev/play/p/OaThj6iNVXK

Example 
m := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
	"d": 4,
}

var sum int
ForEach(m, func(_ string, value int) {
	sum += value
})

fmt.Println(sum)

Output:

10

func FromEntries added in v2.1.16 

func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V

FromEntries creates a map based on a slice of key/value pairs Play: https://go.dev/play/p/fTdu4sCNjQO

Example 
result := FromEntries([]Entry[string, int]{
	{Key: "a", Value: 1},
	{Key: "b", Value: 2},
	{Key: "c", Value: 3},
})

fmt.Println(result)

Output:

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

func Intersect 

func Intersect[K comparable, V any](maps ...map[K]V) map[K]V

Intersect iterates over maps, return a new map of key and value pairs in all given maps. Play: https://go.dev/play/p/Zld0oj3sjcC

Example 
m1 := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
}

m2 := map[string]int{
	"a": 1,
	"b": 2,
	"c": 6,
	"d": 7,
}

m3 := map[string]int{
	"a": 1,
	"b": 9,
	"e": 9,
}

result1 := Intersect(m1)
result2 := Intersect(m1, m2)
result3 := Intersect(m1, m2, m3)

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

Output:

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

func IsDisjoint added in v2.1.3 

func IsDisjoint[K comparable, V any](mapA, mapB map[K]V) bool

IsDisjoint two map are disjoint if they have no keys in common. Play: https://go.dev/play/p/N9qgYg_Ho6f

Example 
m1 := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
}

m2 := map[string]int{
	"d": 22,
}

m3 := map[string]int{
	"a": 22,
}

result1 := IsDisjoint(m1, m2)
result2 := IsDisjoint(m1, m3)

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

Output:

true
false

func Keys 

func Keys[K comparable, V any](m map[K]V) []K

Keys returns a slice of the map's keys. Play: https://go.dev/play/p/xNB5bTb97Wd

Example 
m := map[int]string{
	1: "a",
	2: "a",
	3: "b",
	4: "c",
	5: "d",
}

keys := Keys(m)
sort.Ints(keys)

fmt.Println(keys)

Output:

[1 2 3 4 5]

func KeysBy added in v2.1.16 

func KeysBy[K comparable, V any, T any](m map[K]V, mapper func(item K) T) []T

KeysBy creates a slice whose element is the result of function mapper invoked by every map's key. Play: https://go.dev/play/p/hI371iB8Up8

Example 
m := map[int]string{
	1: "a",
	2: "a",
	3: "b",
}

keys := KeysBy(m, func(n int) int {
	return n + 1
})

sort.Ints(keys)

fmt.Println(keys)

Output:

[2 3 4]

func MapKeys added in v2.1.16 

func MapKeys[K comparable, V any, T comparable](m map[K]V, iteratee func(key K, value V) T) map[T]V

MapKeys transforms a map to other type map by manipulating it's keys. Play: https://go.dev/play/p/8scDxWeBDKd

Example 
m := map[int]string{
	1: "a",
	2: "b",
	3: "c",
}

result := MapKeys(m, func(k int, _ string) string {
	return strconv.Itoa(k)
})

fmt.Println(result)

Output:

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

func MapTo added in v2.1.19 

func MapTo(src any, dst any) error

MapTo try to map any interface to struct or base type 

Eg:
	v := map[string]interface{}{
		"service":map[string]interface{}{
			"ip":"127.0.0.1",
			"port":1234,
		},
		version:"v1.0.01"
	}

	type Target struct {
		Service struct {
			Ip string `json:"ip"`
			Port int `json:"port"`
		} `json:"service"`
		Ver string `json:"version"`
	}

	var dist Target
	if err := maputil.MapTo(v,&dist); err != nil {
		log.Println(err)
		return
	}

	log.Println(dist)

Play: https://go.dev/play/p/4K7KBEPgS5M

Example 
type (
	Person struct {
		Name  string  `json:"name"`
		Age   int     `json:"age"`
		Phone string  `json:"phone"`
		Addr  Address `json:"address"`
	}

	Address struct {
		Street string `json:"street"`
		Number int    `json:"number"`
	}
)

personInfo := map[string]interface{}{
	"name":  "Nothin",
	"age":   28,
	"phone": "123456789",
	"address": map[string]interface{}{
		"street": "test",
		"number": 1,
	},
}

var p Person
err := MapTo(personInfo, &p)

fmt.Println(err)
fmt.Println(p)

Output:

<nil>
{Nothin 28 123456789 {test 1}}

func MapValues added in v2.1.16 

func MapValues[K comparable, V any, T any](m map[K]V, iteratee func(key K, value V) T) map[K]T

MapValues transforms a map to other type map by manipulating it's values. Play: https://go.dev/play/p/g92aY3fc7Iw

Example 
m := map[int]string{
	1: "a",
	2: "b",
	3: "c",
}

result := MapValues(m, func(k int, v string) string {
	return v + strconv.Itoa(k)
})

fmt.Println(result)

Output:

map[1:a1 2:b2 3:c3]

func Merge 

func Merge[K comparable, V any](maps ...map[K]V) map[K]V

Merge maps, next key will overwrite previous key. Play: https://go.dev/play/p/H95LENF1uB-

Example 
m1 := map[int]string{
	1: "a",
	2: "b",
}
m2 := map[int]string{
	1: "c",
	3: "d",
}

result := Merge(m1, m2)

fmt.Println(result)

Output:

map[1:c 2:b 3:d]

func Minus 

func Minus[K comparable, V any](mapA, mapB map[K]V) map[K]V

Minus creates a map of whose key in mapA but not in mapB. Play: https://go.dev/play/p/3u5U9K7YZ9m

Example 
m1 := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
}

m2 := map[string]int{
	"a": 11,
	"b": 22,
	"d": 33,
}

result := Minus(m1, m2)

fmt.Println(result)

Output:

map[c:3]

func OmitBy added in v2.1.16 

func OmitBy[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V

OmitBy is the opposite of Filter, removes all the map elements for which the predicate function returns true. Play: https://go.dev/play/p/YJM4Hj5hNwm

Example 
m := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
	"d": 4,
	"e": 5,
}
isEven := func(_ string, value int) bool {
	return value%2 == 0
}

result := OmitBy(m, isEven)

fmt.Println(result)

Output:

map[a:1 c:3 e:5]

func OmitByKeys added in v2.1.16 

func OmitByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V

OmitByKeys the opposite of FilterByKeys, extracts all the map elements which keys are not omitted. Play: https://go.dev/play/p/jXGrWDBfSRp

Example 
m := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
	"d": 4,
	"e": 5,
}

result := OmitByKeys(m, []string{"a", "b"})

fmt.Println(result)

Output:

map[c:3 d:4 e:5]

func OmitByValues added in v2.1.16 

func OmitByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V

OmitByValues the opposite of FilterByValues. remov all elements whose value are in the give slice. Play: https://go.dev/play/p/XB7Y10uw20_U

Example 
m := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
	"d": 4,
	"e": 5,
}

result := OmitByValues(m, []int{4, 5})

fmt.Println(result)

Output:

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

func Transform added in v2.1.16 

func Transform[K1 comparable, V1 any, K2 comparable, V2 any](m map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2

Transform a map to another type map. Play: https://go.dev/play/p/P6ovfToM3zj

Example 
m := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
}

result := Transform(m, func(k string, v int) (string, string) {
	return k, strconv.Itoa(v)
})

fmt.Println(result)

Output:

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

func Values 

func Values[K comparable, V any](m map[K]V) []V

Values returns a slice of the map's values. Play: https://go.dev/play/p/CBKdUc5FTW6

Example 
m := map[int]string{
	1: "a",
	2: "a",
	3: "b",
	4: "c",
	5: "d",
}

values := Values(m)
sort.Strings(values)

fmt.Println(values)

Output:

[a a b c d]

func ValuesBy added in v2.1.16 

func ValuesBy[K comparable, V any, T any](m map[K]V, mapper func(item V) T) []T

ValuesBy creates a slice whose element is the result of function mapper invoked by every map's value. Play: https://go.dev/play/p/sg9-oRidh8f

Example 
m := map[int]string{
	1: "a",
	2: "b",
	3: "c",
}
values := ValuesBy(m, func(v string) string {
	switch v {
	case "a":
		return "a-1"
	case "b":
		return "b-2"
	case "c":
		return "c-3"
	default:
		return ""
	}
})

sort.Strings(values)

fmt.Println(values)

Output:

[a-1 b-2 c-3]

Types

type Entry added in v2.1.16 

type Entry[K comparable, V any] struct {
	Key   K
	Value V
}

Entry is a key/value pairs.

func Entries added in v2.1.16 

func Entries[K comparable, V any](m map[K]V) []Entry[K, V]

Entries transforms a map into array of key/value pairs. Play: https://go.dev/play/p/Ltb11LNcElY

Example 
m := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
}

result := Entries(m)

sort.Slice(result, func(i, j int) bool {
	return result[i].Value < result[j].Value
})

fmt.Println(result)

Output:

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

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.