Hacker News Reader

> are there any good form validation libraries for Go?

Here are a couple:

http://www.gorillatoolkit.org/pkg/schema

http://godoc.org/github.com/mccoyst/validate

There are also some bigger web framework projects that include validation, Revel is one: http://revel.github.io/manual/validation.html

schema is not a validation library, it just turns HTTP forms into Go structs. Validate uses tags or maps (not a huge issue, granted). The Revel one does look nice, though. Thanks.

I've attacked this from a few angles myself—previously using reflection and struct tags - `min:"2", max:"50"` - but found it fairly inelegant (although practical). I wrote some good tests around it, that's for sure.

Now I'm a fan of https://github.com/katco-/vala which has a nice API for doing this for you. I've ripped out one of the examples from the README (which I think illustrates it well), but you could also wrap this in a method that you call on the instance of the struct you get back from (i.e.) gorilla/schema:

    func ClearValidation(a, b, c MyType) (err error) {
        err = BeginValidation().Validate(
            IsNotNil(a, "a"),
            IsNotNil(b, "b"),
            IsNotNil(c, "c"),
        ).CheckAndPanic().Validate( // Panic will occur here if a, b, or c are nil.
            HasLen(a.Items, 50, "a.Items"),
            GreaterThan(b.UserCount, 0, "b.UserCount"),
            Equals(c.Name, "Vala", "c.name"),
            Not(Equals(c.FriendlyName, "Foo", "c.FriendlyName")),
         ).Check()

         if err != nil {
             return err
         }

        // ...
    }

Note that for any reasonable amount of validation w/ structs (i.e. not nil, ranging over it automatically, etc) you will need reflection. There are no ifs or buts about that. But the whole 'reflection is slow' mantra is premature optimisation: if you need reflection, you need it. Your template rendering uses reflection, your database connection introduces latency, etc - all of that dwarfs any cost associated with validating a struct or two.

Thanks for your response. It is good to hear from someone who has wrestled with the issue.

>couldn't think of a way that did not end up using reflection

The builtin decoders (eg, json) use reflection. You don't lose any of the benefits of static typing as you are still decoding into your statically-typed object.

I would separate form parsing from object validation.

Use something like this: https://github.com/ajg/form to populate statically-typed go structs from form data, and then validate your objects.

There is a speed hit to reflection, though, right?

Also, you do lose the benefit of static typing, for example, the following typo isn't picked up at compile time:

    type User struct {
        Name         string            `form:"nam"`
    }

Tags are rather ugly and don't scale to many options well. What happens when your ORM, form validation library, xml library, and json libraries each need a separate tag? That's a slight exaggeration but you could see how the apparent simplicity in the form example can quickly become anything but.

Heavy use of tags (and reflection) just makes me feel like you have to work around the language too much and I question whether you may as well just use Python, hence my original question.

I've done minimal work with Go, though, so perhaps I'm misinformed.

You're example is not a static typing issue. It's a feature of the library that the struct field doesn't have to have the same name as the form field.

I think the issue is more of a DRY thing, which could maybe be fixed with something like:

    type User struct {
        FirstName string  `form:lowercase_hyphenated`
        LastName  string  `form:lowercase_hyphenated`
    }

This hypothetical syntax would instruct the library to look for the form fields "first-name" and "last-name".

There is a speed hit to reflection. As for the tag issue: writing your own marshaler isn't actually a huge problem. I have been meaning to write my own json marshaler for a while. I personally find the solution much more paletable than many other ways of marshaling in and out of json.

There's a significant speed hit to reflection, but it's going to get lost in the noise if you're making HTTP requests.