Programming language: Go
License: MIT License
Tags: Forms    
Latest version: v1.2.2

conform alternatives and similar packages

Based on the "Forms" category.
Alternatively, view conform alternatives based on common mentions on social networks and blogs.

  • nosurf

    CSRF protection middleware for Go.
  • gorilla/csrf

    DISCONTINUED. gorilla/csrf provides Cross Site Request Forgery (CSRF) prevention middleware for Go web applications & services 🔒
  • Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
    Promo www.influxdata.com
    InfluxDB Logo
  • binding

    DISCONTINUED. Reflectionless data binding for Go's net/http (not actively maintained)
  • form

    :steam_locomotive: Decodes url.Values into Go value(s) and Encodes Go value(s) into url.Values. Dual Array and Full map support.
  • httpin

    🍡 HTTP Input for Go - HTTP Request from/to Go Struct (Bi-directional Data Binding between Go Struct and http.Request)
  • formam

    a package for decode form's values into struct in Go
  • forms

    A lightweight go library for parsing form data or json from an http.Request.
  • qs

    Go module for encoding structs into URL query parameters
  • bind

    Bind form data to any Go values
  • queryparam

    Go package to easily convert a URL's query parameters/values into usable struct values of the correct types.
  • gbind

    Bind data to any Go value. Can use built-in and custom expression binding capabilities; supports data validation logic for Go values. // 将数据绑定到任何 Go 值。可使用内置和自定义表达式绑定能力;支持对Go值的数据校验逻辑.
  • checker

    Checker is a Go library for validating user input through checker rules provided in struct tags.

Do you think we are missing an alternative of conform or a related project?

Add another 'Forms' Package


Conform- keep user input in check (go, golang)

Trim, sanitize, and modify struct string fields in place, based on tags.

Update Jan 12, 2016 -- Now also works with embedded structs

Turns this...

type Person struct {
    FirstName string `conform:"name"`
    LastName  string `conform:"ucfirst,trim"`
    Email     string `conform:"email"`
    CamelCase string `conform:"camel"`
    UserName  string `conform:"snake"`
    Slug      string `conform:"slug"`
    Blurb     string `conform:"title"`
    Left      string `conform:"ltrim"`
    Right     string `conform:"rtrim"`

p1 := Person{
    " LEE ",
    "     Benson",
    "   [email protected]  ",
    "I love new york city",
    "lee benson",
    "this is a little bit about me...",
    "    Left trim   ",
    "    Right trim  ",

Into this...

p2 := p1 // <-- copy the Person struct into a new one, to see the difference
conform.Strings(&p2) // <-- this does the work

    p1 (left) vs. p2 (right)

    FirstName: ' LEE ' -> 'Lee'
    LastName: '     Benson' -> 'Benson'
    Email: '   [email protected]  ' -> '[email protected]'
    CamelCase: 'I love new york city' -> 'ILoveNewYorkCity'
    UserName: 'lee benson' -> 'lee_benson'
    Slug: 'LeeBensonWasHere' -> 'lee-benson-was-here'
    Blurb: 'this is a little bit about me...' -> 'This Is A Little Bit About Me...'
    Left: '    Left trim   ' -> 'Left trim   '
    Right: '    Right trim  ' -> '    Right trim'


Conform helps you fix and format user strings quickly, without writing functions.

If you do form processing with Gorilla Schema or similar, you probably shuttle user data into structs using tags. Adding a conform tag to your string field gives you "first pass" clean up against user input.

Use it for names, e-mail addresses, URL slugs, or any other form field where formatting matters.

Conform doesn't attempt any kind of validation on your fields. Check out govalidator for a slew of common validation funcs, or validator which is an uber-flexible Swiss Army knife for validating pretty much any kind of data you can imagine. Both have struct tag syntax and can be used with conform.

How to use

Grab the package from the command line with:

go get github.com/leebenson/conform

And import in the usual way in your Go app:

import "github.com/leebenson/conform"

Add a conform tag to your structs, for all of the string fields that you want Conform to transform. Add the name of the transform (known as the "tag") in double quotes, and separate multiple tags with commas. Example: conform:"trim,lowercase"

To format in place, pass your struct pointer to conform.Strings.

Note: your struct will be edited in place. This will OVERWRITE any data that is already stored in your string fields.

Here's an example that formats e-mail addresses:

package main

import (

type UserForm struct {
    Email string `conform:"email"`

func main() {
    input := UserForm{
        Email: "   [email protected]  ",
    conform.Strings(&input) // <-- pass in a pointer to your struct
    fmt.Println(input.Email) // prints "[email protected]"

Using with Gorilla Schema

Just add a conform tag along with your Gorilla schema tags:

// ...

import (


// the struct that will be filled from the post request...
type newUserForm struct {
    FirstName string    `schema:"firstName" conform:"name"`
    Email     string    `schema:"emailAddress" conform:"email"`
    Password  string    `schema:"password"`    // <-- no tag? no change
    Dob       time.Time `schema:"dateOfBirth"` // <-- non-strings ignored by conform

// ProcessNewUser attempts to register a new user
func ProcessNewUser(r *http.Request) error {
    form := new(newUserForm)
    schema.NewDecoder().Decode(form, r.PostForm) // <-- Gorilla Schema
    conform.Strings(form)                       // <-- Conform.  Pass in the same pointer that Schema used
    // ...

// HTTP handlers, etc...


See the public API / exported methods on Godoc.


You can use multiple tags in the format of conform:"tag1,tag2"


Trims leading and trailing spaces. Example: " string " -> "string"


Trims leading spaces only. Example: " string " -> "string "


Trims trailing spaces only. Example: " string " -> " string"


Converts string to lowercase. Example: "STRING" -> "string"


Converts string to uppercase. Example: "string" -> "STRING"


Converts string to Title Case, e.g. "this is a sentence" -> "This Is A Sentence"


Converts to camel case via stringUp, Example provided by library: this is it => thisIsIt, this\_is\_it => thisIsIt, this-is-it => thisIsIt


Converts to snake_case. Example: "CamelCase" -> "camel_case", "regular string" -> "regular_string" Special thanks to snaker for inspiration (credited in license)


Turns strings into slugs. Example: "CamelCase" -> "camel-case", "blog title here" -> "blog-title-here"


Uppercases first character. Example: "all lower" -> "All lower"


Trims, strips numbers and special characters (except dashes and spaces separating names), converts multiple spaces and dashes to single characters, title cases multiple names. Example: "3493€848Jo-s$%£@Ann " -> "Jo-Ann", " ~~ The Dude ~~" -> "The Dude", "**susan**" -> "Susan", " hugh fearnley-whittingstall" -> "Hugh Fearnley-Whittingstall"


Trims and lowercases the string. Example: "[email protected] " -> "[email protected]"


Removes all non-numeric characters. Example: "the price is €30,38" -> "3038"

Note: The struct field will remain a string. No type conversion takes place.


Removes all numbers. Example "39472349D34a34v69e8932747" -> "Dave"


Removes non-alpha unicode characters. Example: "!@£$%^&'()Hello 1234567890 World+[];\" -> "HelloWorld"


Removes alpha unicode characters. Example: "Everything's here but the letters!" -> "' !"



*Note that all licence references and agreements mentioned in the conform README section above are relevant to that project's source code only.