Golang解析文本文件的实用教程

Go语言解析文本文件的实用实现

以下是一个完整的Go程序，演示如何解析文本文件并完成您要求的所有分析任务：

package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"os"
	"regexp"
	"sort"
	"strings"
	"unicode"
)

// 单词统计结构
type WordCount struct {
	Word  string
	Count int
}

// 按长度排序的结构
type ByLength []string

func (s ByLength) Len() int           { return len(s) }
func (s ByLength) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
func (s ByLength) Less(i, j int) bool { return len(s[i]) > len(s[j]) }

func main() {
	// 1. 打开文件
	file, err := os.Open("book.txt")
	if err != nil {
		log.Fatal("无法打开文件:", err)
	}
	defer file.Close() // 确保文件关闭

	// 2. 读取文件内容
	content, err := io.ReadAll(file)
	if err != nil {
		log.Fatal("读取文件失败:", err)
	}

	// 3. 转换为字符串
	text := string(content)

	// 4. 提取单词（支持Unicode字符）
	words := extractWords(text)

	// 5. 输出前20个单词
	fmt.Println("=== 前20个单词 ===")
	for i := 0; i < min(20, len(words)); i++ {
		fmt.Printf("%d: %s\n", i+1, words[i])
	}
	fmt.Println()

	// 6. 20个最常用的单词
	fmt.Println("=== 20个最常用的单词 ===")
	commonWords := mostCommonWords(words, 20)
	for i, wc := range commonWords {
		fmt.Printf("%d: %s (%d次)\n", i+1, wc.Word, wc.Count)
	}
	fmt.Println()

	// 7. 20个最长的单词
	fmt.Println("=== 20个最长的单词 ===")
	longestWords := longestWords(words, 20)
	for i, word := range longestWords {
		fmt.Printf("%d: %s (%d字符)\n", i+1, word, len([]rune(word)))
	}
	fmt.Println()

	// 8. 最长的回文词
	fmt.Println("=== 最长的回文词 ===")
	longestPalindrome := findLongestPalindrome(words)
	if longestPalindrome != "" {
		fmt.Printf("最长的回文词: %s (%d字符)\n", 
			longestPalindrome, len([]rune(longestPalindrome)))
	} else {
		fmt.Println("未找到回文词")
	}
}

// 提取单词（支持Unicode）
func extractWords(text string) []string {
	// 使用正则表达式匹配单词字符（包括Unicode字母和所有格撇号）
	re := regexp.MustCompile(`[\p{L}']+`)
	matches := re.FindAllString(text, -1)
	
	// 转换为小写并过滤空字符串
	var words []string
	for _, match := range matches {
		word := strings.ToLower(match)
		if word != "" {
			words = append(words, word)
		}
	}
	return words
}

// 统计最常用的单词
func mostCommonWords(words []string, n int) []WordCount {
	wordMap := make(map[string]int)
	
	// 统计词频
	for _, word := range words {
		wordMap[word]++
	}
	
	// 转换为切片并排序
	var wordCounts []WordCount
	for word, count := range wordMap {
		wordCounts = append(wordCounts, WordCount{word, count})
	}
	
	sort.Slice(wordCounts, func(i, j int) bool {
		if wordCounts[i].Count == wordCounts[j].Count {
			return wordCounts[i].Word < wordCounts[j].Word
		}
		return wordCounts[i].Count > wordCounts[j].Count
	})
	
	if len(wordCounts) > n {
		return wordCounts[:n]
	}
	return wordCounts
}

// 获取最长的单词
func longestWords(words []string, n int) []string {
	// 去重
	uniqueWords := make(map[string]bool)
	var uniqueList []string
	for _, word := range words {
		if !uniqueWords[word] {
			uniqueWords[word] = true
			uniqueList = append(uniqueList, word)
		}
	}
	
	// 按长度排序
	sort.Sort(ByLength(uniqueList))
	
	if len(uniqueList) > n {
		return uniqueList[:n]
	}
	return uniqueList
}

// 检查是否为回文
func isPalindrome(s string) bool {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		if runes[i] != runes[j] {
			return false
		}
	}
	return true
}

// 查找最长的回文词
func findLongestPalindrome(words []string) string {
	var longest string
	seen := make(map[string]bool)
	
	for _, word := range words {
		if !seen[word] && isPalindrome(word) {
			seen[word] = true
			if len([]rune(word)) > len([]rune(longest)) {
				longest = word
			}
		}
	}
	return longest
}

// 辅助函数
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

非英语文本处理说明

对于非英语文本，这个程序有以下处理能力：

1. Unicode支持：使用\p{L}匹配所有Unicode字母字符，可以处理中文、日文、阿拉伯文等
2. 字符计数：使用[]rune进行字符计数，正确处理多字节字符
3. 大小写转换：strings.ToLower()对Unicode字符有效

非英语文本的预期结果：

• 中文/日文：[\p{L}']+会匹配汉字、假名等字符，但可能将连续字符视为一个"单词"
• 阿拉伯文/希伯来文：从右向左书写不影响字符匹配，但回文检测可能不准确
• 带变音符号的语言：如法语、德语，Unicode支持会保留变音符号
• 连字处理：某些语言的特殊连字可能需要额外处理

改进建议（针对多语言）：

// 针对特定语言的分词改进
func extractWordsMultilingual(text string, lang string) []string {
	switch lang {
	case "zh", "ja", "ko":
		// 中日韩文需要更复杂的分词
		re := regexp.MustCompile(`[\p{Han}\p{Hiragana}\p{Katakana}\p{Hangul}]+`)
		return re.FindAllString(text, -1)
	default:
		return extractWords(text)
	}
}

这个程序展示了Go语言处理文件的基本模式：os.Open() → io.ReadAll() → 处理 → defer file.Close()。Go的标准库提供了强大的文本处理能力，特别是regexp包对Unicode的良好支持。