Go 格式化修复 JSON 字符串

package main

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

// FixBasicJSON 修复基础不规范JSON：键加双引号、单引号转双引号、去除尾逗号
// 参数：rawJSON 原始不规范JSON字符串
// 返回：修复后的规范JSON、错误信息
func FixBasicJSON(rawJSON string) (string, error) {
    // 1. 去除JSON中的注释（// 单行注释和 /* */ 多行注释）
    // 匹配单行注释
    commentRegex1 := regexp.MustCompile(`//.*\n`)
    rawJSON = commentRegex1.ReplaceAllString(rawJSON, "\n")
    // 匹配多行注释
    commentRegex2 := regexp.MustCompile(`/\*[\s\S]*?\*/`)
    rawJSON = commentRegex2.ReplaceAllString(rawJSON, "")

    // 2. 将单引号替换为双引号（注意避免替换字符串内部的单引号，这里做基础处理，复杂场景需调整）
    rawJSON = strings.ReplaceAll(rawJSON, "'", "\"")

    // 3. 为未加双引号的键添加双引号（匹配类似 key: 的格式，排除已加引号的情况）
    keyRegex := regexp.MustCompile(`([{,]\s*)([a-zA-Z0-9_]+)(\s*:)`)
    rawJSON = keyRegex.ReplaceAllString(rawJSON, "$1\"$2\"$3")

    // 4. 去除对象/数组末尾的逗号（匹配 }, 或 ], 格式）
    trailingCommaRegex := regexp.MustCompile(`,\s*([}\]])`)
    rawJSON = trailingCommaRegex.ReplaceAllString(rawJSON, " $1")

    // 5. 验证修复后的JSON是否合法
    var temp interface{}
    if err := json.Unmarshal([]byte(rawJSON), &temp); err != nil {
        return "", fmt.Errorf("修复后JSON仍不合法：%w，修复后内容：%s", err, rawJSON)
    }

    // 6. 格式化JSON（可选，按需求决定是否格式化）
    formattedJSON, err := json.MarshalIndent(temp, "", "  ")
    if err != nil {
        return "", fmt.Errorf("JSON格式化失败：%w", err)
    }

    return string(formattedJSON), nil
}

func main() {
    // 测试：不规范的JSON示例
    rawJSON := `{
        name: '张三', // 姓名
        age: 18,
        address: {
            city: '北京',
            street: "长安街"
        },
        hobbies: ['读书', '运动'],
    }`

    // 修复JSON
    fixedJSON, err := FixBasicJSON(rawJSON)
    if err != nil {
        fmt.Printf("JSON修复失败：%v\n", err)
        return
    }

    fmt.Println("修复后的规范JSON：")
    fmt.Println(fixedJSON)
}

package main

import (
    "encoding/json"
    "fmt"

    "github.com/tidwall/gjson"
    "github.com/tidwall/sjson"
)

// FixComplexJSON 复杂JSON修复：基于第三方库，支持更复杂的语法错误
// 参数：rawJSON 原始不规范JSON字符串
// 返回：修复后的规范JSON、错误信息
func FixComplexJSON(rawJSON string) (string, error) {
    // 1. 用gjson解析不规范JSON（gjson对不规范语法兼容性强）
    result := gjson.Parse(rawJSON)
    // 检查解析是否有错误
    if result.Error != nil {
        return "", fmt.Errorf("JSON解析失败：%w（错误位置：行%d，列%d）", 
            result.Error, result.Line, result.Column)
    }

    // 2. 将解析结果转为Go原生数据类型（确保数据结构正确）
    var data interface{}
    if err := json.Unmarshal([]byte(result.Raw), &data); err != nil {
        return "", fmt.Errorf("转换数据结构失败：%w", err)
    }

    // 3. 格式化JSON（可根据需求调整缩进）
    formattedJSON, err := json.MarshalIndent(data, "", "  ")
    if err != nil {
        return "", fmt.Errorf("格式化JSON失败：%w", err)
    }

    // 4. 可选：修改JSON中的特定字段（示例：将age字段加1）
    modifiedJSON, err := sjson.Set(string(formattedJSON), "age", 19)
    if err != nil {
        return "", fmt.Errorf("修改JSON字段失败：%w", err)
    }

    return modifiedJSON, nil
}

func main() {
    // 测试：更复杂的不规范JSON
    rawJSON := `{
        name: '张三',
        age: 18,
        address: {
            city: '北京',
            street: "长安街",
            zip: 100000, // 邮编
        },
        hobbies: ['读书', "运动", '编程'],
        info: {
            "height": 180,
            weight: 70,
        }
    }`

    // 进阶修复
    fixedJSON, err := FixComplexJSON(rawJSON)
    if err != nil {
        fmt.Printf("复杂JSON修复失败：%v\n", err)
        return
    }

    fmt.Println("进阶修复后的JSON：")
    fmt.Println(fixedJSON)
}

import (
    "encoding/json"
    "os"
)

// 流式解析超大JSON
func StreamParseJSON(filePath string) error {
    file, err := os.Open(filePath)
    if err != nil {
        return err
    }
    defer file.Close()

    decoder := json.NewDecoder(file)
    // 解析JSON开头的 { 或 [
    token, err := decoder.Token()
    if err != nil {
        return err
    }
    fmt.Printf("JSON类型：%v\n", token)

    // 逐字段解析
    for decoder.More() {
        var key, value interface{}
        if err := decoder.Decode(&key); err != nil {
            return err
        }
        if err := decoder.Decode(&value); err != nil {
            return err
        }
        fmt.Printf("键：%v，值：%v\n", key, value)
    }
    return nil
}

import (
    "filepath"
    "os"
)

// BatchFixJSON 批量修复目录下的JSON文件
func BatchFixJSON(dirPath string) error {
    return filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        // 只处理JSON文件
        if !info.IsDir() && filepath.Ext(path) == ".json" {
            // 读取文件内容
            content, err := os.ReadFile(path)
            if err != nil {
                return fmt.Errorf("读取文件[%s]失败：%w", path, err)
            }
            // 修复JSON
            fixedContent, err := FixBasicJSON(string(content))
            if err != nil {
                return fmt.Errorf("修复文件[%s]失败：%w", path, err)
            }
            // 覆盖写入修复后的内容
            if err := os.WriteFile(path, []byte(fixedContent), 0644); err != nil {
                return fmt.Errorf("写入文件[%s]失败：%w", path, err)
            }
            fmt.Printf("成功修复文件：%s\n", path)
        }
        return nil
    })
}