Golang高效读取文件内容的实现方法

Golang高效读取文件内容的实现方法 你好，

我有一个包含数百万条记录的JSON文件，格式如下。可以想象，一次性读取整个文件内容在内存使用上并不高效。在Go语言中，我们应如何处理这类问题？出于演示目的，我不介意看到一种在读取文件内容时同时打印结构体的解决方案。

谢谢

user.json

{
  "ID-1": {
    "username": "name-1",
    "password": "password-1"
  },
  "ID-2": {
    "username": "name-2",
    "password": "password-2"
  },
  "ID-3": {
    "username": "name-3",
    "password": "password-3"
  }
}

用户结构体（如果其他结构体能简化解决方案，也可以使用）

type User struct {
	ID       string `json:"id"`
	Username string `json:"username"`
	Password string `json:"password"`
}

更多关于Golang高效读取文件内容的实现方法的实战教程也可以访问 https://www.itying.com/category-94-b0.html

2 回复

听起来你需要的是 json.Decoder。你可以编写一个函数，解码你的 User 结构体的令牌，并通过通道或函数返回结果。

func main() {
    fmt.Println("hello world")
}

更多关于Golang高效读取文件内容的实现方法的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


对于处理大型JSON文件，可以使用encoding/json包的Decoder进行流式读取。以下是示例代码：

package main

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

type User struct {
    ID       string `json:"id"`
    Username string `json:"username"`
    Password string `json:"password"`
}

func main() {
    file, err := os.Open("user.json")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    decoder := json.NewDecoder(file)

    // 读取起始的'{'
    token, err := decoder.Token()
    if err != nil {
        panic(err)
    }
    if delim, ok := token.(json.Delim); !ok || delim != '{' {
        panic("expected object")
    }

    // 逐条处理记录
    for decoder.More() {
        // 读取键（用户ID）
        var id string
        if err := decoder.Decode(&id); err != nil {
            panic(err)
        }

        // 读取值（用户对象）
        var userData map[string]string
        if err := decoder.Decode(&userData); err != nil {
            panic(err)
        }

        // 构建User结构体
        user := User{
            ID:       id,
            Username: userData["username"],
            Password: userData["password"],
        }

        // 处理用户数据（这里只是打印）
        fmt.Printf("Processed: %+v\n", user)
    }

    // 读取结束的'}'
    token, err = decoder.Token()
    if err != nil {
        panic(err)
    }
}

如果需要更精确的解析，可以使用自定义解码：

func main() {
    file, err := os.Open("user.json")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    decoder := json.NewDecoder(file)

    // 直接解析为map[string]User
    var data map[string]struct {
        Username string `json:"username"`
        Password string `json:"password"`
    }

    if err := decoder.Decode(&data); err != nil {
        panic(err)
    }

    // 流式处理
    for id, userData := range data {
        user := User{
            ID:       id,
            Username: userData.Username,
            Password: userData.Password,
        }
        fmt.Printf("Processed: %+v\n", user)
    }
}

对于特别大的文件，还可以结合bufio.Reader：

func main() {
    file, err := os.Open("user.json")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    reader := bufio.NewReaderSize(file, 64*1024) // 64KB缓冲区
    decoder := json.NewDecoder(reader)

    // ... 使用decoder进行流式解析
}

这些方法都能在常量内存下处理任意大小的JSON文件。

回到顶部