Files
wasm-go/main.go
lychang 5e3dac3020 init
2026-05-19 19:42:55 +08:00

637 lines
14 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package main
import (
"archive/zip"
"fmt"
"io"
"os"
"strconv"
"strings"
)
type SheetInfo struct {
Name string
SheetID int
RID string
Path string
}
type XLSXReader struct {
files map[string][]byte
sheetMap map[string]SheetInfo
}
func main() {
fmt.Println("========== Excel转Markdown表格 ==========")
excelFile := "yst郑州惠兴财务报表2021(3).xlsx"
fmt.Printf("Excel文件: %s\n\n", excelFile)
reader, err := NewXLSXReader(excelFile)
if err != nil {
fmt.Printf("❌ 创建XLSX读取器失败: %v\n", err)
return
}
fmt.Println("✓ 创建XLSX读取器成功")
// 打印所有文件列表
fmt.Println("\n--- 压缩包内文件列表 ---")
for name := range reader.files {
if strings.HasPrefix(name, "xl/worksheets/") {
fmt.Printf(" %s\n", name)
}
}
sheets, err := reader.GetSheetNames()
if err != nil {
fmt.Printf("❌ 获取工作表名称失败: %v\n", err)
return
}
fmt.Printf("\n✓ 获取到 %d 个工作表:\n", len(sheets))
for i, sheet := range sheets {
if info, ok := reader.sheetMap[sheet]; ok {
fmt.Printf(" %d. %s -> rId=%s, path=%s\n", i+1, sheet, info.RID, info.Path)
} else {
fmt.Printf(" %d. %s\n", i+1, sheet)
}
}
for i, sheetName := range sheets {
fmt.Printf("\n========== 工作表: %s ==========\n", sheetName)
data, err := reader.GetSheetData(sheetName)
if err != nil {
fmt.Printf("❌ 读取工作表失败: %v\n", err)
continue
}
if len(data) == 0 {
fmt.Println("⚠️ 工作表为空")
continue
}
fmt.Printf("找到 %d 行数据\n", len(data))
if len(data[0]) > 0 {
fmt.Printf("表格尺寸: %d 行 × %d 列\n", len(data), len(data[0]))
fmt.Printf("前3行预览:\n")
for r := 0; r < min(len(data), 3); r++ {
rowData := make([]string, 0, len(data[r]))
for c := 0; c < min(len(data[r]), 4); c++ {
val := data[r][c]
if len(val) > 20 {
val = val[:20] + "..."
}
rowData = append(rowData, fmt.Sprintf("%q", val))
}
fmt.Printf(" 第%d行: %s\n", r+1, strings.Join(rowData, ", "))
}
}
markdown := ConvertToMarkdown(data)
safeName := sanitizeFileName(sheetName)
err = SaveToFile(markdown, fmt.Sprintf("sheet%d_%s.md", i+1, safeName))
if err != nil {
fmt.Printf("❌ 保存文件失败: %v\n", err)
} else {
fmt.Printf("✓ 已保存到: sheet%d_%s.md\n", i+1, safeName)
}
}
fmt.Println("\n✅ 所有工作表已转换完成!")
}
func sanitizeFileName(name string) string {
name = strings.ReplaceAll(name, "/", "_")
name = strings.ReplaceAll(name, "\\", "_")
name = strings.ReplaceAll(name, ":", "_")
name = strings.ReplaceAll(name, "*", "_")
name = strings.ReplaceAll(name, "?", "_")
name = strings.ReplaceAll(name, "\"", "_")
name = strings.ReplaceAll(name, "<", "_")
name = strings.ReplaceAll(name, ">", "_")
name = strings.ReplaceAll(name, "|", "_")
return name
}
func NewXLSXReader(filePath string) (*XLSXReader, error) {
f, err := os.Open(filePath)
if err != nil {
return nil, fmt.Errorf("打开文件失败: %v", err)
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
return nil, fmt.Errorf("获取文件信息失败: %v", err)
}
zr, err := zip.NewReader(f, fi.Size())
if err != nil {
return nil, fmt.Errorf("创建zip读取器失败: %v", err)
}
files := make(map[string][]byte)
for _, file := range zr.File {
f, err := file.Open()
if err != nil {
return nil, fmt.Errorf("打开内部文件失败: %v", err)
}
content, err := io.ReadAll(f)
f.Close()
if err != nil {
return nil, fmt.Errorf("读取内部文件失败: %v", err)
}
files[file.Name] = content
}
reader := &XLSXReader{files: files}
reader.parseWorkbook()
return reader, nil
}
func (r *XLSXReader) parseWorkbook() {
r.sheetMap = make(map[string]SheetInfo)
// 收集所有可用的worksheet文件
var availableSheets []string
for file := range r.files {
if strings.HasPrefix(file, "xl/worksheets/sheet") && strings.HasSuffix(file, ".xml") {
availableSheets = append(availableSheets, file)
}
}
fmt.Printf("✓ 发现 %d 个可用的worksheet文件: %v\n", len(availableSheets), availableSheets)
// 读取rels文件获取正确的映射关系
ridToPath := r.readWorkbookRels()
fmt.Printf("✓ 从rels文件读取到 %d 个映射关系\n", len(ridToPath))
content, ok := r.files["xl/workbook.xml"]
if !ok {
return
}
contentStr := string(content)
var sheetNames []string
idx := 0
for {
sheetStart := strings.Index(contentStr[idx:], "<sheet ")
if sheetStart == -1 {
break
}
sheetStart += idx
nameAttrStart := strings.Index(contentStr[sheetStart:], `name="`)
if nameAttrStart == -1 {
idx = sheetStart + 6
continue
}
nameAttrStart += sheetStart + 6
nameAttrEnd := strings.Index(contentStr[nameAttrStart:], `"`)
if nameAttrEnd == -1 {
idx = nameAttrStart + 1
continue
}
nameAttrEnd += nameAttrStart
name := contentStr[nameAttrStart:nameAttrEnd]
sheetID := 0
sheetIdAttr := strings.Index(contentStr[nameAttrEnd:], `sheetId="`)
if sheetIdAttr != -1 {
sheetIdAttr += nameAttrEnd + 9
sheetIdEnd := strings.Index(contentStr[sheetIdAttr:], `"`)
if sheetIdEnd != -1 {
sheetIdEnd += sheetIdAttr
if id, err := strconv.Atoi(contentStr[sheetIdAttr:sheetIdEnd]); err == nil {
sheetID = id
}
}
}
rid := ""
ridAttr := strings.Index(contentStr[nameAttrEnd:], `r:id="`)
if ridAttr != -1 {
ridAttr += nameAttrEnd + 6
ridEnd := strings.Index(contentStr[ridAttr:], `"`)
if ridEnd != -1 {
ridEnd += ridAttr
rid = contentStr[ridAttr:ridEnd]
}
}
path := ""
if rid != "" && ridToPath[rid] != "" {
path = ridToPath[rid]
if r.files[path] == nil {
path = ""
}
}
if path == "" && rid != "" {
sheetNum := strings.TrimPrefix(rid, "rId")
path = fmt.Sprintf("xl/worksheets/sheet%s.xml", sheetNum)
if r.files[path] == nil {
path = ""
}
}
if path == "" && sheetID > 0 {
path = fmt.Sprintf("xl/worksheets/sheet%d.xml", sheetID)
if r.files[path] == nil {
path = ""
}
}
if path == "" && len(availableSheets) > 0 {
usedPaths := make(map[string]bool)
for _, info := range r.sheetMap {
usedPaths[info.Path] = true
}
for _, availPath := range availableSheets {
if !usedPaths[availPath] {
path = availPath
break
}
}
}
sheetNames = append(sheetNames, name)
r.sheetMap[name] = SheetInfo{
Name: name,
SheetID: sheetID,
RID: rid,
Path: path,
}
idx = nameAttrEnd + 1
}
fmt.Printf("✓ 工作簿中定义了 %d 个工作表\n", len(sheetNames))
}
func (r *XLSXReader) readWorkbookRels() map[string]string {
result := make(map[string]string)
content, ok := r.files["xl/_rels/workbook.xml.rels"]
if !ok {
fmt.Println("⚠️ 找不到 xl/_rels/workbook.xml.rels 文件")
return result
}
contentStr := string(content)
idx := 0
for {
relStart := strings.Index(contentStr[idx:], `<Relationship `)
if relStart == -1 {
break
}
relStart += idx
idAttr := strings.Index(contentStr[relStart:], `Id="`)
if idAttr == -1 {
idx = relStart + 14
continue
}
idAttr += relStart + 4
idEnd := strings.Index(contentStr[idAttr:], `"`)
if idEnd == -1 {
idx = idAttr + 1
continue
}
idEnd += idAttr
rid := contentStr[idAttr:idEnd]
targetAttr := strings.Index(contentStr[idEnd:], `Target="`)
if targetAttr == -1 {
idx = idEnd + 1
continue
}
targetAttr += idEnd + 8
targetEnd := strings.Index(contentStr[targetAttr:], `"`)
if targetEnd == -1 {
idx = targetAttr + 1
continue
}
targetEnd += targetAttr
target := contentStr[targetAttr:targetEnd]
if strings.HasPrefix(target, "worksheets/") {
result[rid] = "xl/" + target
}
idx = targetEnd + 1
}
return result
}
func (r *XLSXReader) GetSheetNames() ([]string, error) {
var names []string
for name := range r.sheetMap {
names = append(names, name)
}
return names, nil
}
func (r *XLSXReader) GetSheetData(sheetName string) ([][]string, error) {
sheetInfo, ok := r.sheetMap[sheetName]
if !ok {
return nil, fmt.Errorf("找不到工作表: %s", sheetName)
}
if sheetInfo.Path == "" {
return nil, fmt.Errorf("无法确定工作表 %s 的文件路径", sheetName)
}
sheetContent, ok := r.files[sheetInfo.Path]
if !ok {
// 尝试查找所有worksheet文件
fmt.Printf("⚠️ 找不到文件: %s\n", sheetInfo.Path)
fmt.Println(" 可用的worksheet文件:")
for file := range r.files {
if strings.HasPrefix(file, "xl/worksheets/") {
fmt.Printf(" - %s\n", file)
}
}
return nil, fmt.Errorf("找不到工作表文件: %s", sheetInfo.Path)
}
sharedStrings := r.loadSharedStrings()
fmt.Printf("✓ 加载到 %d 个共享字符串\n", len(sharedStrings))
return r.parseSheetData(string(sheetContent), sharedStrings), nil
}
func (r *XLSXReader) loadSharedStrings() []string {
content, ok := r.files["xl/sharedStrings.xml"]
if !ok {
return nil
}
contentStr := string(content)
var sharedStrings []string
siIdx := 0
for {
siStart := strings.Index(contentStr[siIdx:], "<si>")
if siStart == -1 {
break
}
siStart += siIdx
siEnd := strings.Index(contentStr[siStart:], "</si>")
if siEnd == -1 {
break
}
siEnd += siStart
siContent := contentStr[siStart+4 : siEnd]
var text strings.Builder
tIdx := 0
for {
tStart := strings.Index(siContent[tIdx:], "<t")
if tStart == -1 {
break
}
tStart += tIdx
tCloseTag := strings.Index(siContent[tStart:], ">")
if tCloseTag == -1 {
break
}
tCloseTag += tStart
tEnd := strings.Index(siContent[tCloseTag:], "</t>")
if tEnd == -1 {
break
}
tEnd += tCloseTag
text.WriteString(siContent[tCloseTag+1 : tEnd])
tIdx = tEnd + 4
}
sharedStrings = append(sharedStrings, text.String())
siIdx = siEnd + 5
}
return sharedStrings
}
func (r *XLSXReader) parseSheetData(contentStr string, sharedStrings []string) [][]string {
sheetDataStart := strings.Index(contentStr, "<sheetData>")
if sheetDataStart == -1 {
return nil
}
sheetDataEnd := strings.Index(contentStr[sheetDataStart:], "</sheetData>")
if sheetDataEnd == -1 {
return nil
}
sheetDataEnd += sheetDataStart
sheetData := contentStr[sheetDataStart+11 : sheetDataEnd]
var result [][]string
maxCol := 0
rowIdx := 0
for {
rowStart := strings.Index(sheetData[rowIdx:], "<row ")
if rowStart == -1 {
break
}
rowStart += rowIdx
rowEnd := strings.Index(sheetData[rowStart:], "</row>")
if rowEnd == -1 {
break
}
rowEnd += rowStart
rowContent := sheetData[rowStart : rowEnd+6]
rowNumber := len(result) + 1
rowNumAttr := strings.Index(rowContent, ` r="`)
if rowNumAttr != -1 {
rowNumAttr += 4
rowNumEnd := strings.Index(rowContent[rowNumAttr:], `"`)
if rowNumEnd != -1 {
if rn, err := strconv.Atoi(rowContent[rowNumAttr : rowNumAttr+rowNumEnd]); err == nil {
for len(result) < rn-1 {
result = append(result, []string{})
}
rowNumber = rn
}
}
}
rowData := []string{}
cellIdx := 0
for {
cellStart := strings.Index(rowContent[cellIdx:], "<c ")
if cellStart == -1 {
break
}
cellStart += cellIdx
cellEnd := strings.Index(rowContent[cellStart:], "</c>")
if cellEnd == -1 {
break
}
cellEnd += cellStart
cellContent := rowContent[cellStart : cellEnd+4]
cellRef := ""
refAttr := strings.Index(cellContent, ` r="`)
if refAttr != -1 {
refAttr += 4
refEnd := strings.Index(cellContent[refAttr:], `"`)
if refEnd != -1 {
cellRef = cellContent[refAttr : refAttr+refEnd]
}
}
if cellRef == "" {
cellIdx = cellEnd + 4
continue
}
colIndex := getColumnIndex(cellRef)
cellType := ""
typeAttr := strings.Index(cellContent, ` t="`)
if typeAttr != -1 {
typeAttr += 4
typeEnd := strings.Index(cellContent[typeAttr:], `"`)
if typeEnd != -1 {
cellType = cellContent[typeAttr : typeAttr+typeEnd]
}
}
val := ""
vStart := strings.Index(cellContent, "<v>")
if vStart != -1 {
vStart += 3
vEnd := strings.Index(cellContent[vStart:], "</v>")
if vEnd != -1 {
val = cellContent[vStart : vStart+vEnd]
if cellType == "s" && sharedStrings != nil {
if idx, err := strconv.Atoi(val); err == nil && idx >= 0 && idx < len(sharedStrings) {
val = sharedStrings[idx]
}
}
}
}
for len(rowData) <= colIndex {
rowData = append(rowData, "")
}
rowData[colIndex] = val
if colIndex > maxCol {
maxCol = colIndex
}
cellIdx = cellEnd + 4
}
for len(result) < rowNumber {
result = append(result, []string{})
}
result[rowNumber-1] = rowData
rowIdx = rowEnd + 6
}
for i := range result {
for len(result[i]) <= maxCol {
result[i] = append(result[i], "")
}
}
return result
}
func getColumnIndex(cellRef string) int {
i := 0
for i < len(cellRef) {
c := cellRef[i]
if c < 'A' || c > 'Z' {
break
}
i++
}
colStr := cellRef[:i]
col := 0
for _, c := range colStr {
col = col*26 + int(c-'A') + 1
}
return col - 1
}
func ConvertToMarkdown(data [][]string) string {
if len(data) == 0 {
return "表格为空"
}
var result strings.Builder
numCols := 0
for _, row := range data {
if len(row) > numCols {
numCols = len(row)
}
}
for rowIdx, row := range data {
result.WriteString("|")
for colIdx := 0; colIdx < numCols; colIdx++ {
val := ""
if colIdx < len(row) {
val = escapeMarkdown(row[colIdx])
}
result.WriteString(fmt.Sprintf(" %s |", val))
}
result.WriteString("\n")
if rowIdx == 0 {
result.WriteString("|")
for colIdx := 0; colIdx < numCols; colIdx++ {
result.WriteString(" --- |")
}
result.WriteString("\n")
}
}
return result.String()
}
func escapeMarkdown(text string) string {
text = strings.ReplaceAll(text, "\\", "\\\\")
text = strings.ReplaceAll(text, "|", "\\|")
text = strings.ReplaceAll(text, "[", "\\[")
text = strings.ReplaceAll(text, "]", "\\]")
text = strings.ReplaceAll(text, "(", "\\(")
text = strings.ReplaceAll(text, ")", "\\)")
text = strings.ReplaceAll(text, "#", "\\#")
text = strings.ReplaceAll(text, "*", "\\*")
text = strings.ReplaceAll(text, "_", "\\_")
return text
}
func SaveToFile(content, filename string) error {
return os.WriteFile(filename, []byte(content), 0644)
}
func min(a, b int) int {
if a < b {
return a
}
return b
}