Go 中没有反射的动态检查的最佳模式？

Question

Any chance there are good patterns in any of our codebases that help reduce redundant checks on typed fields/structs? I feel like Lisp handles these things well, but trying to understand if there are any good patterns without the need for something like reflection, etc.

For example, for custom structs, I find myself needing to do a lot of:

type helloworld struct {
 field1 *string
 field2 *string
 field3 int
}
if field1 != nil { 
  if len([]rune(*field1)) > MAX_ALLOWED_LEN) return errors.New("exceeded max allowable length")
}
if field2 != nil { 
  if len([]rune(*field2)) > MAX_ALLOWED_LEN) return errors.New("exceeded max allowable length")
}
if field3 != 0 { //do stuff}
....

maps are great, but typing can be too generic a lot of the time, which can also cause confusion. I ask, because some of these checks are redundant and proliferate through a lot of packages, so when I need to add an additional field, refactoring is time consuming. It would be nice if I have validation on certain types or fields while keeping performance high.

Answer 1

3 directions, not the most straight forward, but they can reduce your check blocks:

Method 1: Define your own annotation

Golang has annotations in structs

type bla struct {
  t string `json:"some,omitempty"`
}

This is actually an open annotation structure (tags).

A nice example (contains some reflection) is https://github.com/mitchellh/mapstructure

Look at line 374 of the mapstructure.go file. It is pretty re-usable, and you could use it as base for your own annotation.

To use it in your context you would create types which you can then parse.

Method 2: DRY check function

Your check seems to be the same or similar.

A generic comparator which iterates over fields:

func check(fields ...interface{}) error {
  for v:=range fields {
    if v==nil {
      return errors.New("nil")
    }
    switch v.type() {
      case *string:
        if len([]rune(*v)) > MAX_ALLOWED_LEN) {
          return errors.New("exceeded max allowable length")
        }
      }
      ...
    }
}

Method 3: Generics.

The switch type in method 2 might be able to be rewritten in a generic style. Not easier, but can be prettier.