golang用户输入数据清洗与校验插件库conform的使用

Golang用户输入数据清洗与校验插件库conform的使用

Conform是一个用于处理用户输入的Golang库，它可以通过结构体标签来修剪、清理和修改字符串字段。

功能概述

Conform可以帮助你快速修复和格式化用户输入的字符串，而无需编写额外的函数。它特别适合处理表单数据，如姓名、电子邮件地址、URL slugs等需要格式化的字段。

安装

使用以下命令安装conform：

go get github.com/leebenson/conform

然后在代码中导入：

import "github.com/leebenson/conform"

基本用法

示例1：格式化电子邮件地址

package main

import (
    "fmt"
    "github.com/leebenson/conform"
)

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

func main() {
    input := UserForm{
        Email: "   POORLYFormaTTED@EXAMPlE.COM  ",
    }
    conform.Strings(&input) // 传入结构体指针
    fmt.Println(input.Email) // 输出 "poorlyformatted@example.com"
}

示例2：多种格式化操作

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"`

    Skills   []string          `conform:"upper"`
    Examples map[string]string `conform:"!html"`
}

p1 := Person{
    " LEE ",
    "     Benson",
    "   LEE@LEEbenson.com  ",
    "I love new york city",
    "lee benson",
    "LeeBensonWasHere",
    "this is a little bit about me...",
    "    Left trim   ",
    "    Right trim  ",
    []string{"HtmL", "Yaml"},
    map[string]string{"<best>":"<body><p>I know this & that.</p></body>"},
}

p2 := p1 // 复制Person结构体到新变量
conform.Strings(&p2) // 执行格式化操作

/*
格式化结果：
FirstName: ' LEE ' -> 'Lee'
LastName: '     Benson' -> 'Benson'
Email: '   LEE@LEEbenson.com  ' -> 'lee@leebenson.com'
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',
Skills: { 'HtmL', 'Yaml' } -> { 'HTML', 'YAML' },
Examples: { '<best>': '<body><p>I know this & that.</p></body>' } -> { '<best>': '&lt;body&gt;&lt;p&gt;I know this &amp; that.&lt;/p&gt;&lt;/body&gt;' }
*/

与Gorilla Schema配合使用

import (
    "net/http"
    "time"

    "github.com/gorilla/schema"
    "github.com/leebenson/conform"
)

type newUserForm struct {
    FirstName string    `schema:"firstName" conform:"name"`
    Email     string    `schema:"emailAddress" conform:"email"`
    Password  string    `schema:"password"`    // 没有conform标签，不做处理
    Dob       time.Time `schema:"dateOfBirth"` // 非字符串字段会被conform忽略
}

func ProcessNewUser(r *http.Request) error {
    form := new(newUserForm)
    schema.NewDecoder().Decode(form, r.PostForm) // Gorilla Schema解码
    conform.Strings(form)                       // Conform格式化
    // ...
}

支持的标签

Conform支持多种格式化标签，可以组合使用：

基本格式化

  • trim - 去除首尾空格
  • ltrim - 去除左侧空格
  • rtrim - 去除右侧空格
  • lower - 转换为小写
  • upper - 转换为大写
  • title - 转换为标题格式

特殊格式

  • camel - 转换为驼峰命名
  • snake - 转换为下划线命名
  • slug - 转换为URL友好的slug格式
  • ucfirst - 首字母大写
  • name - 格式化姓名（去除特殊字符，正确格式化多部分姓名）
  • email - 格式化电子邮件地址

内容过滤

  • num - 只保留数字
  • !num - 去除数字
  • alpha - 只保留字母
  • !alpha - 去除字母
  • !html - 转义HTML
  • !js - 转义JavaScript

注意事项

  1. Conform会原地修改结构体中的字符串字段，会覆盖原有的数据
  2. 只会处理带有conform标签的字符串字段
  3. 不会修改map的键，只会修改值
  4. 非字符串字段会被忽略

Conform不提供验证功能，可以与govalidator或validator等验证库配合使用。


更多关于golang用户输入数据清洗与校验插件库conform的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang用户输入数据清洗与校验插件库conform的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Golang 数据清洗与校验插件库 Conform 使用指南

Conform 是一个轻量级的 Go 库，专门用于数据清洗和校验。它可以对结构体字段进行标准化处理，如去除空格、大小写转换、HTML 标签清理等。

安装 Conform

go get github.com/leebenson/conform

基本使用

1. 定义结构体并添加标签

type User struct {
    Name     string `conform:"name"`     // 将姓名格式化为首字母大写
    Email    string `conform:"email"`    // 将电子邮件转为小写
    Username string `conform:"trim"`     // 去除用户名两端的空格
    Bio      string `conform:"trim,upper"` // 去除空格并转为大写
    HTML     string `conform:"strip"`    // 去除HTML标签
}

2. 使用 Conform 处理数据

package main

import (
    "fmt"
    "github.com/leebenson/conform"
)

func main() {
    user := User{
        Name:     " john doe ",
        Email:    "John@EXAMPLE.COM",
        Username: "  user123  ",
        Bio:      "  <p>This is a bio</p>  ",
        HTML:     "<script>alert('xss')</script><p>Content</p>",
    }

    // 清洗数据
    if err := conform.Strings(&user); err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Printf("Name: %q\n", user.Name)     // "John Doe"
    fmt.Printf("Email: %q\n", user.Email)   // "john@example.com"
    fmt.Printf("Username: %q\n", user.Username) // "user123"
    fmt.Printf("Bio: %q\n", user.Bio)       // "THIS IS A BIO"
    fmt.Printf("HTML: %q\n", user.HTML)     // "Content"
}

支持的转换器

Conform 提供了多种内置的转换器：

  • trim - 去除两端空格
  • ltrim - 去除左端空格
  • rtrim - 去除右端空格
  • lower - 转为小写
  • upper - 转为大写
  • title - 每个单词首字母大写
  • name - 姓名格式（首字母大写）
  • email - 电子邮件格式（转为小写）
  • snake - 转为 snake_case
  • camel - 转为 camelCase
  • ucfirst - 首字母大写
  • strip - 去除 HTML 标签
  • num - 只保留数字字符

自定义转换器

你可以注册自己的转换器：

package main

import (
    "fmt"
    "github.com/leebenson/conform"
    "strings"
)

func init() {
    // 注册自定义转换器
    conform.RegisterCustom("reverse", func(s string) string {
        runes := []rune(s)
        for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
            runes[i], runes[j] = runes[j], runes[i]
        }
        return string(runes)
    })
}

type Data struct {
    Text string `conform:"reverse"`
}

func main() {
    data := Data{Text: "hello"}
    conform.Strings(&data)
    fmt.Println(data.Text) // 输出 "olleh"
}

嵌套结构体处理

Conform 可以递归处理嵌套的结构体：

type Address struct {
    Street string `conform:"trim,title"`
    City   string `conform:"trim,title"`
}

type Person struct {
    Name    string  `conform:"name"`
    Address Address `conform:"nested"`
}

func main() {
    person := Person{
        Name: " john smith ",
        Address: Address{
            Street: " 123 main st  ",
            City:   " new york  ",
        },
    }

    conform.Strings(&person)

    fmt.Printf("Name: %q\n", person.Name)           // "John Smith"
    fmt.Printf("Street: %q\n", person.Address.Street) // "123 Main St"
    fmt.Printf("City: %q\n", person.Address.City)    // "New York"
}

错误处理

Conform 会返回错误，你可以捕获并处理：

type Invalid struct {
    Field int `conform:"trim"` // 不能对非字符串字段使用字符串转换器
}

func main() {
    data := Invalid{Field: 123}
    if err := conform.Strings(&data); err != nil {
        fmt.Println("Error:", err) // 会输出错误
    }
}

性能考虑

Conform 使用反射来处理结构体，对于性能敏感的场景，建议：

  1. 仅在输入边界使用（如 HTTP 请求处理）
  2. 避免在热路径中频繁使用
  3. 对大型结构体考虑手动处理关键字段

总结

Conform 是一个简单易用的数据清洗库，特别适合处理用户输入数据。通过结构体标签，你可以轻松定义各种清洗规则，保持代码整洁。对于更复杂的校验需求，可以结合其他校验库如 go-playground/validator 一起使用。

回到顶部