检查不同的Go map类型中是否存在重复的键。

huangapple
go评论111阅读模式
英文:

Check duplicated keys in different go map types

问题

我想要一个函数来检查不同地图中的重复键。

这是我目前的代码：

  1. ma := map[string]typeA
  2. mb := map[string]typeB
  3. mc := map[string]typeC
  5. dup := map[string]bool{}
  6. for k := range ma {
  7.     if !dup[k] {
  8.         dup[k] = true
  9.     } else {
  10.         return fmt.Errorf("duplicate key[%v]", k)
  11.     }
  12. }
  13. for k := range mb {
  14.     if !dup[k] {
  15.         dup[k] = true
  16.     } else {
  17.         return fmt.Errorf("duplicate key[%v]", k)
  18.     }
  19. }
  20. for k := range mc {
  21.     if !dup[k] {
  22.         dup[k] = true
  23.     } else {
  24.         return fmt.Errorf("duplicate key[%v]", k)
  25.     }
  26. }
  27. return nil

我想要重构这段代码，并编写一个函数：

  1. func checkDupKeys[M ~map[K]V, K comparable, V any](maps ...M) error {
  2.     dup := map[K]bool{}
  3.     for _, m := range maps {
  4.         for k := range m {
  5.             if !dup[k] {
  6.                 dup[k] = true
  7.             } else {
  8.                 return fmt.Errorf("duplicate key[%v]", k)
  9.             }
  10.         }
  11.     }
  12.     return nil
  13. }

但是它只能接受具有相同类型的地图，而不能接受typeA、typeB和typeC。

英文:

I want to have a function to check duplicated keys in different maps.

This is what I have

  1. ma := map[string]typeA
  2. mb := map[string]typeB
  3. mc := map[string]typeC
  5. dup := map[string]bool{}
  6. 	for k := range ma{
  7. 		if !dup[k] {
  8. 			dup[k] = true
  9. 		} else {
  10. 			return fmt.Errorf("duplicate key[%v]", k)
  11. 		}
  12. 	}
  13. 	for k := range mb{
  14. 		if !dup[k] {
  15. 			dup[k] = true
  16. 		} else {
  17. 			return fmt.Errorf("duplicate key[%v]", k)
  18. 		}
  19. 	}
  20. 	for k := range mc {
  21. 		if !dup[k] {
  22. 			dup[k] = true
  23. 		} else {
  24. 			return fmt.Errorf("duplicate key[%v]", k)
  25. 		}
  26. 	}
  27. 	return nil

I want to refactor this and I write a function

  1. func checkDupKeys[M ~map[K]V, K comparable, V any](maps ...M) error {
  2. 	dup := map[K]bool{}
  3. 	for _, m := range maps {
  4. 		for k := range m {
  5. 			if !dup[k] {
  6. 				dup[k] = true
  7. 			} else {
  8. 				return fmt.Errorf("duplicate key[%v]", k)
  9. 			}
  10. 		}
  11. 	}
  12. 	return nil
  13. }

But It can only accept maps with the same type, not typeA, typeB and typeC.

答案1

得分: 2

你可以尝试使用any类型和反射。

  1. func checkDupKeys(maps ...any) error {
  2.     dup := map[any]bool{}
  3.     for i, m := range maps {
  4.         t := reflect.TypeOf(m)
  5.         if t.Kind() != reflect.Map {
  6.             return fmt.Errorf("不是一个映射，在索引位置：%d", i)
  7.         }
  8.         keys := reflect.ValueOf(m).MapKeys()
  9.         for _, k := range keys {
  10.             v := k.Interface()
  11.             if !dup[v] {
  12.                 dup[v] = true
  13.             } else {
  14.                 return fmt.Errorf("重复的键[%v]", v)
  15.             }
  16.         }
  17.     }
  18.     return nil
  19. }

这种方法的缺点是该函数也会接受非映射类型的参数，而编译器不会对此发出警告。

英文:

You can try using any type and reflection

  1. func checkDupKeys(maps ...any) error {
  2. 	dup := map[any]bool{}
  3. 	for i, m := range maps {
  4. 		t := reflect.TypeOf(m)
  5. 		if t.Kind() != reflect.Map {
  6. 			return fmt.Errorf("not a map at index: %d", i)
  7. 		}
  8. 		keys := reflect.ValueOf(m).MapKeys()
  9. 		for _, k := range keys {
  10. 			v := k.Interface()
  11. 			if !dup[v] {
  12. 				dup[v] = true
  13. 			} else {
  14. 				return fmt.Errorf("duplicate key[%v]", v)
  15. 			}
  16. 		}
  17. 	}
  18. 	return nil
  19. }

Disadvantage of this approach is the fact that this function will also accept non-map arguments and compiler will not warn you about this.

答案2

得分: 1

如果我想要实现这个函数，我会选择不同的方法。

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"reflect"
  6. )
  8. func main() {
  9. 	ma := map[string]int{"one": 1, "two": 2}
  10. 	mb := map[string]string{"one": "one"}
  11. 	mc := map[string]float64{"one": 1.1}
  12. 	fmt.Println(checkDupKeys(ma, mb, mc))
  14. }
  16. func checkDupKeys(maps ...interface{}) error {
  17. 	dup := map[string]bool{}
  18. 	for _, m := range maps {
  19. 		v := reflect.ValueOf(m).MapKeys()
  20. 		for _, k := range v {
  21. 			if !dup[k.Interface().(string)] {
  22. 				dup[k.Interface().(string)] = true
  23. 			} else {
  24. 				return fmt.Errorf("重复的键[%v]", k)
  25. 			}
  26. 		}
  27. 	}
  28. 	return nil
  29. }

playground

英文:

If I wanted to implement that function, I would chose a different approach

  1.     package main
  3. import (
  4. 	"fmt"
  5. 	"reflect"
  6. )
  8. func main() {
  9. 	ma := map[string]int{"one": 1, "two": 2}
  10. 	mb := map[string]string{"one": "one"}
  11. 	mc := map[string]float64{"one": 1.1}
  12. 	fmt.Println(checkDupKeys(ma, mb, mc))
  14. }
  15. func checkDupKeys(maps ...any) error {
  16. 	dup := map[string]bool{}
  17. 	for _, m := range maps {
  18. 		v := reflect.ValueOf(m).MapKeys()
  19. 		for _, k := range v {
  20. 			if !dup[k.Interface().(string)] {
  21. 				dup[k.Interface().(string)] = true
  22. 			} else {
  23. 				return fmt.Errorf("duplicate key[%v]", k)
  24. 			}
  25. 		}
  26. 	}
  27. 	return nil
  28. }

playground

huangapple
  • 本文由 发表于 2023年2月10日 14:35:27
  • 转载请务必保留本文链接：https://go.coder-hub.com/75407664.html
  • generics
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定