Golang 从字符串提取值并填充结构体的 NLP 解析插件

在 Go 语言中，我们可以使用 NLP (自然语言处理) 技术从非结构化文本中提取结构化数据并填充到结构体中。以下是几种常见方法和示例代码：

1. 使用正则表达式提取

对于简单的文本模式匹配，可以使用正则表达式：

package main

import (
	"fmt"
	"regexp"
)

type Person struct {
	Name  string
	Age   int
	Email string
}

func main() {
	text := "姓名: 张三, 年龄: 30, 邮箱: zhangsan@example.com"
	
	reName := regexp.MustCompile(`姓名:\s*([^,]+)`)
	reAge := regexp.MustCompile(`年龄:\s*(\d+)`)
	reEmail := regexp.MustCompile(`邮箱:\s*([^\s]+)`)
	
	var person Person
	if matches := reName.FindStringSubmatch(text); len(matches) > 1 {
		person.Name = matches[1]
	}
	if matches := reAge.FindStringSubmatch(text); len(matches) > 1 {
		fmt.Sscanf(matches[1], "%d", &person.Age)
	}
	if matches := reEmail.FindStringSubmatch(text); len(matches) > 1 {
		person.Email = matches[1]
	}
	
	fmt.Printf("%+v\n", person)
}

2. 使用 NLP 库 - Prose

Prose 是一个轻量级的 Go 自然语言处理库：

package main

import (
	"fmt"
	"log"
	"github.com/jdkato/prose/v2"
)

type DocumentInfo struct {
	Entities []string
	People   []string
}

func extractWithProse(text string) DocumentInfo {
	doc, err := prose.NewDocument(text)
	if err != nil {
		log.Fatal(err)
	}

	var info DocumentInfo
	for _, ent := range doc.Entities() {
		info.Entities = append(info.Entities, ent.Text)
		if ent.Label == "PERSON" {
			info.People = append(info.People, ent.Text)
		}
	}
	return info
}

func main() {
	text := "苹果公司由史蒂夫·乔布斯、史蒂夫·沃兹尼亚克和罗纳德·韦恩创立于1976年4月1日。"
	result := extractWithProse(text)
	fmt.Printf("%+v\n", result)
}

3. 使用更高级的 NLP 库 - GoNLP

对于更复杂的 NLP 任务，可以使用 GoNLP：

package main

import (
	"fmt"
	"github.com/gonlp/conllu"
	"github.com/gonlp/morfeusz"
)

type SentenceAnalysis struct {
	Tokens    []string
	Lemmas    []string
	PosTags   []string
}

func analyzeSentence(text string) SentenceAnalysis {
	// 初始化 Morfeusz 分析器
	analyzer, err := morfeusz.New()
	if err != nil {
		panic(err)
	}
	defer analyzer.Close()

	// 分析句子
	segments := analyzer.Analyze(text)
	
	var result SentenceAnalysis
	for _, seg := range segments {
		result.Tokens = append(result.Tokens, seg.Form)
		result.Lemmas = append(result.Lemmas, seg.Lemma)
		result.PosTags = append(result.PosTags, seg.PosTag)
	}
	
	return result
}

func main() {
	text := "快速棕色狐狸跳过懒狗"
	result := analyzeSentence(text)
	fmt.Printf("%+v\n", result)
}

4. 使用 JSON/XML 标签自动映射

如果文本是半结构化的(如 JSON/XML)，可以使用结构体标签：

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type User struct {
	Username string `json:"username" xml:"username"`
	Level    int    `json:"level" xml:"level"`
	Active   bool   `json:"active" xml:"active"`
}

func main() {
	// 从JSON提取
	jsonText := `{"username": "user123", "level": 5, "active": true}`
	var userFromJSON User
	json.NewDecoder(strings.NewReader(jsonText)).Decode(&userFromJSON)
	fmt.Printf("From JSON: %+v\n", userFromJSON)

	// 从XML提取(需要添加encoding/xml导入)
	// xmlText := `<User><username>user123</username><level>5</level><active>true</active></User>`
	// var userFromXML User
	// xml.Unmarshal([]byte(xmlText), &userFromXML)
	// fmt.Printf("From XML: %+v\n", userFromXML)
}

5. 自定义解析器

对于特定领域的文本，可以创建自定义解析器：

package main

import (
	"fmt"
	"strconv"
	"strings"
)

type Product struct {
	ID       int
	Name     string
	Price    float64
	InStock  bool
}

func parseProduct(text string) (Product, error) {
	parts := strings.Split(text, "|")
	if len(parts) != 4 {
		return Product{}, fmt.Errorf("invalid product format")
	}

	var p Product
	var err error
	
	p.ID, err = strconv.Atoi(strings.TrimSpace(parts[0]))
	if err != nil {
		return Product{}, err
	}
	
	p.Name = strings.TrimSpace(parts[1])
	
	p.Price, err = strconv.ParseFloat(strings.TrimSpace(parts[2]), 64)
	if err != nil {
		return Product{}, err
	}
	
	p.InStock = strings.ToLower(strings.TrimSpace(parts[3])) == "true"
	
	return p, nil
}

func main() {
	text := "123 | 笔记本电脑 | 1299.99 | true"
	product, err := parseProduct(text)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Printf("%+v\n", product)
}

总结

1. 对于简单模式，使用正则表达式是最快捷的方法
2. 对于自然语言文本，可以使用 Prose 或 GoNLP 等 NLP 库
3. 对于半结构化数据(JSON/XML)，使用标准库的编码包
4. 对于特定领域文本，创建自定义解析器通常是最佳选择

选择哪种方法取决于你的具体需求、文本的复杂程度以及性能要求。