Is it possible to assert types dynamically in golang?

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

Is it possible to assert types dynamically in golang?

问题

我有一个名为Deduplicate的方法，它将传入的切片作为interface{}返回去重后的副本。有没有办法将此方法返回的interface{}值转换为与我在此方法中传入的相同类型，而无需显式编写它？例如，如果我将myStruct.RelatedIDs的类型从[]int更改为[]uint，它将阻止代码编译。

以下是代码示例：

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"reflect"
  6. )
  8. type myStruct struct {
  9. 	ID         int
  10. 	RelatedIDs []int
  11. }
  13. func main() {
  14. 	s := &myStruct{
  15. 		ID:         42,
  16. 		RelatedIDs: []int{1, 1, 2, 3},
  17. 	}
  18. 	v, _ := Deduplicate(s.RelatedIDs)
  19. 	s.RelatedIDs = v.([]int) // << 在这里我能动态断言类型吗？
  20. 	// s.RelatedIDs = v.(reflect.TypeOf(s.RelatedIDs)) // 不起作用
  21. 	fmt.Printf("%#v\n", s.RelatedIDs)
  22. }
  24. func Deduplicate(slice interface{}) (interface{}, error) {
  25. 	if reflect.TypeOf(slice).Kind() != reflect.Slice {
  26. 		return nil, fmt.Errorf("slice has wrong type: %T", slice)
  27. 	}
  29. 	s := reflect.ValueOf(slice)
  30. 	res := reflect.MakeSlice(s.Type(), 0, s.Len())
  32. 	seen := make(map[interface{}]struct{})
  33. 	for i := 0; i < s.Len(); i++ {
  34. 		v := s.Index(i)
  35. 		if _, ok := seen[v.Interface()]; ok {
  36. 			continue
  37. 		}
  38. 		seen[v.Interface()] = struct{}{}
  39. 		res = reflect.Append(res, v)
  40. 	}
  42. 	return res.Interface(), nil
  43. }

请注意，我只会返回翻译好的部分，不会回答关于翻译的问题。

英文:

I have a method Deduplicate that returns deduplicated copy of passed in slice as an interface{}. Is there a way to cast returned by this method interface{} value to the same type as I passed in this method without writing it explicitly? For example, if I change myStruct.RelatedIDs type from []int to []uint it will prevent code from compiling.

https://play.golang.org/p/8OT4xYZuwEn

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;reflect&quot;
  6. )
  8. type myStruct struct {
  9. 	ID         int
  10. 	RelatedIDs []int
  11. }
  13. func main() {
  14. 	s := &amp;myStruct{
  15. 		ID:         42,
  16. 		RelatedIDs: []int{1, 1, 2, 3},
  17. 	}
  18. 	v, _ := Deduplicate(s.RelatedIDs)
  19. 	s.RelatedIDs = v.([]int) // &lt;&lt; can I assert type dynamically here?
  20. 	// s.RelatedIDs = v.(reflect.TypeOf(s.RelatedIDs)) // does not work
  21. 	fmt.Printf(&quot;%#v\n&quot;, s.RelatedIDs)
  22. }
  24. func Deduplicate(slice interface{}) (interface{}, error) {
  25. 	if reflect.TypeOf(slice).Kind() != reflect.Slice {
  26. 		return nil, fmt.Errorf(&quot;slice has wrong type: %T&quot;, slice)
  27. 	}
  29. 	s := reflect.ValueOf(slice)
  30. 	res := reflect.MakeSlice(s.Type(), 0, s.Len())
  32. 	seen := make(map[interface{}]struct{})
  33. 	for i := 0; i &lt; s.Len(); i++ {
  34. 		v := s.Index(i)
  35. 		if _, ok := seen[v.Interface()]; ok {
  36. 			continue
  37. 		}
  38. 		seen[v.Interface()] = struct{}{}
  39. 		res = reflect.Append(res, v)
  40. 	}
  42. 	return res.Interface(), nil
  43. }

答案1

得分: 3

请稍等，我会为您翻译这段代码。

英文:

Try this

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;reflect&quot;
  6. )
  8. type myStruct struct {
  9. 	ID         int
  10. 	RelatedIDs []int
  11. }
  13. func main() {
  14. 	s := &amp;myStruct{
  15. 		ID:         42,
  16. 		RelatedIDs: []int{1, 1, 2, 3},
  17. 	}
  18. 	err := Deduplicate(&amp;s.RelatedIDs)
  19. 	fmt.Println(err)
  20. 	// s.RelatedIDs = v.([]int) // &lt;&lt; can I assert type dynamically here?
  21. 	// s.RelatedIDs = v.(reflect.TypeOf(s.RelatedIDs)) // does not work
  22. 	fmt.Printf(&quot;%#v\n&quot;, s.RelatedIDs)
  23. }
  25. func Deduplicate(slice interface{}) error {
  26. 	rts := reflect.TypeOf(slice)
  27. 	rtse := rts.Elem()
  28. 	if rts.Kind() != reflect.Ptr &amp;&amp; rtse.Kind() != reflect.Slice {
  29. 		return fmt.Errorf(&quot;slice has wrong type: %T&quot;, slice)
  30. 	}
  32. 	rvs := reflect.ValueOf(slice)
  33. 	rvse := rvs.Elem()
  35. 	seen := make(map[interface{}]struct{})
  36. 	var e int
  37. 	for i := 0; i &lt; rvse.Len(); i++ {
  38. 		v := rvse.Index(i)
  39. 		if _, ok := seen[v.Interface()]; ok {
  40. 			continue
  41. 		}
  42. 		seen[v.Interface()] = struct{}{}
  43. 		rvse.Index(e).Set(v)
  44. 		e++
  45. 	}
  47. 	rvse.SetLen(e)
  48. 	rvs.Elem().Set(rvse)
  50. 	return nil
  51. }

https://play.golang.org/p/hkEW4u1aGUi

with future generics, it might look like this https://go2goplay.golang.org/p/jobI5wKR8fU

答案2

得分: 2

以下是翻译好的内容：

为了完整起见，这里是一个通用版本的代码（Playground），它不需要使用反射。只能在2022年2月之后打开！然而，关于NaN的常规注意事项仍然适用。

  1. package main
  3. import (
  4. 	"fmt"
  5. )
  7. func main() {
  8. 	s := []int{1, 1, 2, 3}
  9. 	res := Deduplicate(s)
  10. 	fmt.Printf("%#v\n", res)
  11. }
  13. func Deduplicate[T comparable](s []T) []T {
  14. 	seen := make(map[T]struct{})
  15. 	res := make([]T, 0, len(s))
  16. 	for _, elem := range s {
  17. 		if _, exists := seen[elem]; exists {
  18. 			continue
  19. 		}
  20. 		seen[elem] = struct{}{}
  21. 		res = append(res, elem)
  22. 	}
  23. 	return res
  24. }

输出结果：

  1. []int{1, 2, 3}
英文:

For completeness, here is a generic version (Playground), which doesn't require reflection. Only open in February 2022! The usual caveats about NaN apply, though.

  1. package main
  2. import (
  3. &quot;fmt&quot;
  4. )
  5. func main() {
  6. s := []int{1, 1, 2, 3}
  7. res := Deduplicate(s)
  8. fmt.Printf(&quot;%#v\n&quot;, res)
  9. }
  10. func Deduplicate[T comparable](s []T) []T {
  11. seen := make(map[T]struct{})
  12. res := make([]T, 0, len(s))
  13. for _, elem := range s {
  14. if _, exists := seen[elem]; exists {
  15. continue
  16. }
  17. seen[elem] = struct{}{}
  18. res = append(res, elem)
  19. }
  20. return res
  21. }

Output:

  1. []int{1, 2, 3}

huangapple
  • 本文由 发表于 2021年7月24日 03:00:55
  • 转载请务必保留本文链接：https://go.coder-hub.com/68503982.html
  • assertion
  • go
  • reflect
  • types
匿名

发表评论

匿名网友

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

确定