maputil

package
v0.0.0-...-654d6e8 Latest Latest
Warning

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

 Go to latest Published: Aug 17, 2024 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Overview

Package maputil includes some functions to manipulate map.

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 

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 

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 

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 HasKey 

func HasKey[K comparable, V any](m map[K]V, key K) bool

HasKey checks if map has key or not. This function is used to replace the following boilerplate code: _, haskey := amap["baz"]; 

if haskey {
   fmt.Println("map has key baz")
}

Play: https://go.dev/play/p/isZZHOsDhFc

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

result1 := HasKey(m, "a")
result2 := HasKey(m, "c")

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

Output:

true
false

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 

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 

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 

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 

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 MapToStruct 

func MapToStruct(m map[string]any, structObj any) error

MapToStruct converts map to struct Play: https://go.dev/play/p/7wYyVfX38Dp

Example 
personReqMap := map[string]any{
	"name":     "Nothin",
	"max_age":  35,
	"page":     1,
	"pageSize": 10,
}

type PersonReq struct {
	Name     string `json:"name"`
	MaxAge   int    `json:"max_age"`
	Page     int    `json:"page"`
	PageSize int    `json:"pageSize"`
}
var personReq PersonReq
_ = MapToStruct(personReqMap, &personReq)
fmt.Println(personReq)

Output:

{Nothin 35 1 10}

func MapValues 

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 

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 

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 

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 ToSortedSlicesDefault 

func ToSortedSlicesDefault[K constraints.Ordered, V any](m map[K]V) ([]K, []V)

ToSortedSlicesDefault converts a map to two slices sorted by key: one for the keys and another for the values. Play: https://go.dev/play/p/43gEM2po-qy

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

keys, values := ToSortedSlicesDefault(m)

fmt.Println(keys)
fmt.Println(values)

Output:

[1 2 3]
[a b c]

func ToSortedSlicesWithComparator 

func ToSortedSlicesWithComparator[K comparable, V any](m map[K]V, comparator func(a, b K) bool) ([]K, []V)

ToSortedSlicesWithComparator converts a map to two slices sorted by key and using a custom comparison function: one for the keys and another for the values. Play: https://go.dev/play/p/0nlPo6YLdt3

Example 
m1 := map[time.Time]string{
	time.Date(2024, 3, 31, 0, 0, 0, 0, time.UTC): "today",
	time.Date(2024, 3, 30, 0, 0, 0, 0, time.UTC): "yesterday",
	time.Date(2024, 4, 1, 0, 0, 0, 0, time.UTC):  "tomorrow",
}

keys1, values1 := ToSortedSlicesWithComparator(m1, func(a, b time.Time) bool {
	return a.Before(b)
})

m2 := map[int]string{
	1: "a",
	3: "c",
	2: "b",
}
keys2, values2 := ToSortedSlicesWithComparator(m2, func(a, b int) bool {
	return a > b
})

fmt.Println(keys1)
fmt.Println(values1)

fmt.Println(keys2)
fmt.Println(values2)

Output:

[2024-03-30 00:00:00 +0000 UTC 2024-03-31 00:00:00 +0000 UTC 2024-04-01 00:00:00 +0000 UTC]
[yesterday today tomorrow]
[3 2 1]
[c b a]

func Transform 

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 

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 ConcurrentMap 

type ConcurrentMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

ConcurrentMap is like map, but is safe for concurrent use by multiple goroutines.

func NewConcurrentMap 

func NewConcurrentMap[K comparable, V any](shardCount int) *ConcurrentMap[K, V]

NewConcurrentMap create a ConcurrentMap with specific shard count. Play: https://go.dev/play/p/3PenTPETJT0

func (*ConcurrentMap[K, V]) Delete 

func (cm *ConcurrentMap[K, V]) Delete(key K)

Delete the value for a key. Play: https://go.dev/play/p/uTIJZYhpVMS

func (*ConcurrentMap[K, V]) Get 

func (cm *ConcurrentMap[K, V]) Get(key K) (V, bool)

Get the value stored in the map for a key, or nil if no. Play: https://go.dev/play/p/3PenTPETJT0

func (*ConcurrentMap[K, V]) GetAndDelete 

func (cm *ConcurrentMap[K, V]) GetAndDelete(key K) (actual V, ok bool)

GetAndDelete returns the existing value for the key if present and then delete the value for the key. Otherwise, do nothing, just return false Play: https://go.dev/play/p/ZyxeIXSZUiM

func (*ConcurrentMap[K, V]) GetOrSet 

func (cm *ConcurrentMap[K, V]) GetOrSet(key K, value V) (actual V, ok bool)

GetOrSet returns the existing value for the key if present. Otherwise, it sets and returns the given value. Play: https://go.dev/play/p/aDcDApOK01a

func (*ConcurrentMap[K, V]) Has 

func (cm *ConcurrentMap[K, V]) Has(key K) bool

Has checks if map has the value for a key. Play: https://go.dev/play/p/C8L4ul9TVwf

func (*ConcurrentMap[K, V]) Range 

func (cm *ConcurrentMap[K, V]) Range(iterator func(key K, value V) bool)

Range calls iterator sequentially for each key and value present in each of the shards in the map. If iterator returns false, range stops the iteration. Play: https://go.dev/play/p/iqcy7P8P0Pr

func (*ConcurrentMap[K, V]) Set 

func (cm *ConcurrentMap[K, V]) Set(key K, value V)

Set the value for a key. Play: https://go.dev/play/p/3PenTPETJT0

type Entry 

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

Entry is a key/value pairs.

func Entries 

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.