Golang读取文件和处理超大文件方案

最新推荐文章于 2024-09-11 08:39:26 发布
最新推荐文章于 2024-09-11 08:39:26 发布
阅读量7k 收藏 21
点赞数 7
分类专栏： Golang 文章标签： golang go 后端
楚江云
本文链接：https://blog.csdn.net/weixin_37717557/article/details/106482955
版权

文章目录

Golang 操作文件的读取的方法很多,适用的场景也是各不相同,在此我们将文件的读取分为如下几种 :

  1. 文件整体读取
  2. 文件分片读取(块级读取)
  3. 文件行级读取

系统的配置不同,执行的耗时也不相同,此处给出一参考

系统配置 :

OS : Windows10

Memory : 16G

CPU (英特尔)Intel® Core™ i3-4370 CPU @ 3.80GHz(3800 MHz)

1. 文件整体读取

文件整体读取就是将文件一次性读取到,理解上是将文件的内容第一次就读取完了

使用场景 :

  1. 针对小文件比较合适(大文件读取空间和时间的消耗也很大)
  2. 对于整体性强的文件也比较合适(文件也不能太大)
代码示例1
package main

import (
	"bufio"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"os"
	"time"
)
// 测试用的文本文件11M大小
var m11 string = `G:\runtime\log\ccapi\11M.log`
// 测试用的文本文件400M大小
var m400 string = `G:\runtime\log\ccapi\400M.log`

// 将整个文件都读取
func readAll(filePath string) {
	start1 := time.Now()
	ioutil.ReadFile(filePath)
	fmt.Println("readAll spend : ", time.Now().Sub(start1))
}
func main() {
	readAll(m11)
	readAll(m400)
}

$ go run main.go
readAll spend :  6.9999ms
readAll spend :  358.8014ms
代码示例2
package main

import (
	"bufio"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"os"
	"time"
)
// 测试用的文本文件11M大小
var m11 string = `G:\runtime\log\ccapi\11M.log`
// 测试用的文本文件400M大小
var m400 string = `G:\runtime\log\ccapi\400M.log`
// 将文件完整读取
func readAllBuff(filePath string) {
	start1 := time.Now()
	// 打开文件
	FileHandle, err := os.Open(filePath)
	if err != nil {
		log.Println(err)
		return
	}
	// 关闭文件
	defer FileHandle.Close()
	// 获取文件当前信息
	fileInfo, err := FileHandle.Stat()
	if err != nil {
		log.Println(err)
		return
	}
	buffer := make([]byte, fileInfo.Size())
	// 读取文件内容,并写入buffer中
	n, err := FileHandle.Read(buffer)
	if err != nil {
		log.Println(err)
	}
	// 打印所有切片中的内容
	fmt.Println(string(buffer[:n]))
	fmt.Println("readAllBuff spend : ", time.Now().Sub(start1))
}
func main() {
	readAllBuff(m11)
	readAllBuff(m400)
}
2. 文件分片读取

对文件一部分一部分逐步的读取,直到文件完全读取完

PS : 每次读取文件的大小是根据设置的 分片 大小 ,所以对于读取文本类型的文件时(例如 : 日志文件)
不一定是按照你的期望逐行输出,因为不会处理文本尾部的换行符,而是按照分片大小读取内容

使用场景 :

  1. 读取超大的文件很合适
  2. 读二进制类型的文件很合适(比如:音视频文件或者资源类型文件等)
代码示例
package main

import (
	"bufio"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"os"
	"time"
)
// 测试用的文本文件11M大小
var m11 string = `G:\runtime\log\ccapi\11M.log`
// 测试用的文本文件400M大小
var m400 string = `G:\runtime\log\ccapi\400M.log`
// 文件一块一块的读取
func readBlock(filePath string) {
	start1 := time.Now()
	FileHandle, err := os.Open(filePath)
	if err != nil {
		log.Println(err)
		return
	}
	defer FileHandle.Close()
    // 设置每次读取字节数
	buffer := make([]byte, 1024)
	for {
		n, err := FileHandle.Read(buffer)
		// 控制条件,根据实际调整
		if err != nil && err != io.EOF {
			log.Println(err)
		}
		if n == 0 {
			break
		}
		// 如下代码打印出每次读取的文件块(字节数)
		//fmt.Println(string(buffer[:n]))
	}
	fmt.Println("readBolck spend : ", time.Now().Sub(start1))
}
func main() {
	readBlock(m11)
	readBlock(m400)
}

$ go run main.go
readBolck spend :  31.9814ms
readBolck spend :  1.0889488s
3. 文件逐行读取

对文件一行一行的读取,直到读到文件末尾

使用场景 :

  1. 读取超大的文件很合适(例如 : 超大log文件等)
  2. 读取的文件最好是有换行的(如果使用单行文件组成的大文件,需要注意)
  3. 对需要分析内容的大文件
    1. 统计某些数据出现的次数
    2. 查询某些数据是否存在
    3. 查找指定行的数据
示例代码1
package main

import (
	"bufio"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"os"
	"time"
)
// 测试用的文本文件11M大小
var m11 string = `G:\runtime\log\ccapi\11M.log`
// 测试用的文本文件400M大小
var m400 string = `G:\runtime\log\ccapi\400M.log`
// 读取文件的每一行
func readEachLineReader(filePath string) {
	start1 := time.Now()
	FileHandle, err := os.Open(filePath)
	if err != nil {
		log.Println(err)
		return
	}
	defer FileHandle.Close()
	lineReader := bufio.NewReader(FileHandle)
	for {
        // 相同使用场景下可以采用的方法
		// func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)
		// func (b *Reader) ReadBytes(delim byte) (line []byte, err error)
		// func (b *Reader) ReadString(delim byte) (line string, err error)
		line, _, err := lineReader.ReadLine()
		if err == io.EOF {
			break
		}
		// 如下是某些业务逻辑操作
		// 如下代码打印每次读取的文件行内容
		fmt.Println(string(line))
	}
	fmt.Println("readEachLineReader spend : ", time.Now().Sub(start1))
}
func main(){
    readEachLineReader(m11)
	readEachLineReader(m400)
}

$ go run main.go
readEachLineReader spend :  16.9902ms
readEachLineReader spend :  537.9683ms
代码示例2
package main

import (
	"bufio"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"os"
	"time"
)
// 测试用的文本文件11M大小
var m11 string = `G:\runtime\log\ccapi\11M.log`
// 测试用的文本文件400M大小
var m400 string = `G:\runtime\log\ccapi\400M.log`
// 读取文件的每一行
func readEachLineScanner(filePath string) {
	start1 := time.Now()
	FileHandle, err := os.Open(filePath)
	if err != nil {
		log.Println(err)
		return
	}
	defer FileHandle.Close()
	lineScanner := bufio.NewScanner(FileHandle)
	for lineScanner.Scan() {
        // 相同使用场景下可以使用如下方法
		// func (s *Scanner) Bytes() []byte
		// func (s *Scanner) Text() string
		// 实际逻辑 : 对读取的内容进行某些业务操作
		// 如下代码打印每次读取的文件行内容
		fmt.Println(lineScanner.Text())
	}
	fmt.Println("readEachLineScanner spend : ", time.Now().Sub(start1))
}
func main() {
	readEachLineScanner(m11)
	readEachLineScanner(m400)
}

$ go run main.go
readEachLineScanner spend :  17.9895ms
readEachLineScanner spend :  574.1722ms
4. 总结

  1. 面试中常见的类似超大文件读取的问题,通常我们采用分片读取或者逐行读取的方案即可

    1. 大文件的上传也可以采用类似的解决方案 , 每次读取文件的部分内容上传(写入)网络接口中,直至文件读取完毕

  2. 普通的小文件并且对内容没有太多操作的,可以采用整体读取,速度相对较快

  3. 对文件内容有操作的采用分片读取和逐行读取更合适

  4. 二进制类型文件采用分片读取或者整体读取的方案比较合适

  5. 文件读取不仅是本地文件,要读去网络上的文件(各种文档,音视频,图片,和其他各种类型文件)时要访问到文件获取 io.ReadCloser 或者 io.Reader 后可以采用三种方式将文件内容读取到

    1. func ReadAll(r io.Reader) ([]byte, error) 文件完整读取

    2. func Copy(dst Writer, src Reader) (written int64, err error) 文件读取并写入

    3. type Reader interface {
    Read(p []byte) (n int, err error)
}

      通过Reader 接口的 Read 方法读取

有疏漏 , 万望指正 , 不胜感谢

5. 参考资料

- [1] Golang文档

楚江云
关注
专栏目录
Golang超大文件读取的两种方案
BttcOptimized的博客
09-24 342
在处理这些文件时，我们可以采用分块读取的方法。这两种方案提供了处理超大文件的方法。根据文件的类型和需求，选择合适的方案来处理大型文件，可以提高程序的效率和性能。逐行读取是一种常见的处理大型文件的方法。它通过逐行读取文件内容，每次只将一行数据加载到内存中。在处理大型文件时，内存的有效管理是至关重要的。在Golang中，我们可以采用以下两种方案来读取超大文件，以确保高效的文件处理。方法来读取文件内容，并将读取到的数据存储在一个缓冲区中。方法来迭代读取每一行数据，然后可以在循环体内对每行数据进行处理。
深入了解Golang中多线程读取大文件
canduecho的专栏
06-27 1171
在golang中，多线程读取一个大文件是一个常见的需求。本文将详细解释如何实现这个功能，并介绍学习目标和学习内容。
golang读取文件，按行读取，写入文件
热门推荐
猛犸象
06-17 1万+
读取文件 读文件方式一：利用ioutil.ReadFile直接从文件读取到[]byte中 func Read0() (string){ f, err := ioutil.ReadFile("file/test") if err != nil { fmt.Println("read fail", err) } return string(f) } 读文件方式二：先从文件读取到file中，在从file读取到buf, buf在追加到最终的[]byte func
Golang数据流处理：掌握Reader和Writer接口的技巧
最新发布
walkskyer的博客
09-11 1252
Reader接口位于Golang的io参数说明p []byte: 这是一个字节切片，用于存储读取到的数据。返回值说明n int: 表示成功读取的字节数。err error: 如果读取过程中发生错误，将返回一个非nil的错误值；如果读取到文件末尾，通常会返回io.EOF。通过实现这个接口，您可以定义自己的数据源，并使用标准库中的工具对其进行操作。同样地，Writer接口也位于io参数说明p []byte: 包含要写入的数据的字节切片。返回值说明n int: 表示成功写入的字节数。err error。
Golang并发读取超大文件
rayylee
06-03 5067
当今世界的任何计算机系统每天都会生成大量的日志或数据。随着系统的发展，将调试数据存储到数据库中是不可行的，因为它们是不可变的，并且只能用于分析和解决故障。所以大部分公司倾向于将日志存储在文件中，而这些文件通常位于本地磁盘中。 我们将使用Go语言，从一个大小为16GB的.txt或.log文件中提取日志。 让我们开始编码…… 首先，我们打开文件。对于任何文件的IO，我们都将使用标准的Go库os.File。 f, err := os.Open(fileName) if err != nil { fmt.P
golang 解析大xml文件
xinyu391的专栏
10-17 2085
golang 解析很大的xml   in, err := os.Open(os.Args[1]) defer in.Close() decoder := xml.NewDecoder(in) var t xml.Token var text bool for t, err = decoder.Token(); err == nil; t, err = decoder.Token(...
Golang 逆序读取文件行
q1009020096的博客
03-09 850
思路 通过Seek函数从末尾移动游标然后每次读取一个字节 判断是否为换行符 换行符，新起一个逆序buff，新建字符串 非换行符，加入缓冲buff 直到文档开头，或限制行数。 实现 import ( "fmt" "io" "os" ) func main() { f, err := os.Open("readend/test.log") if err != nil { panic(fmt.Sprintf("open file error:%s", err.Error())) }
golang 读文件
01-07
go语言读文件学习总结 1、使用指针对象读文件 package main import ( fmt io os ) func main() { file, err := os.Open(./main.go) if err != nil { fmt.Println(open file failed) return } defer file.Close() var content []byte var buf [128]byte for { n, err := file.Read(buf[:]) if err == io.EOF {
如何利用Golang解析读取Mysql备份文件
09-09
在特定情况下，如误操作导致数据丢失，恢复过程可能复杂，而通过编程语言来读取和处理这些大文件可以提供高效且灵活的解决方案。 首先，让我们了解MySQL的备份文件。通常，MySQL的备份文件是以SQL脚本的形式存在的...
基于Golang和Vue的文件管理系统源码.zip
05-27
总的来说，这个基于Golang和Vue.js的文件管理系统结合了两者的优点，提供了一个高效、稳定且用户友好的解决方案。开发者可以通过阅读源码学习到Web开发的最佳实践，以及如何结合不同技术栈构建复杂的应用。
golang实战之truncate日志文件详解
09-20
Golang实战之truncate日志文件详解为我们提供了多种处理大日志文件的技术方案，从基础的命令行操作到深入的文件系统编程都有涉及，旨在帮助开发者更高效地管理日志文件，避免因日志文件过大导致的资源浪费和性能问题...
浅谈Golang是如何读取文件内容的(7种)
09-16
主要介绍了浅谈Golang是如何读取文件内容的，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Go-go-wordsfilter是一个高性能的Go敏感词过滤器
08-14
go-wordsfilter 是一个高性能的 Go 敏感词过滤器，通过预先读取敏感词源并构建树状结构数据的方式来高效地检测和替换敏感词
Golang 超大文件读取的两个方案
cpongo011702
04-15 8781
Golang超大文件读取的两个方案 流处理方式 分片处理 去年的面试中我被问到超大文件你怎么处理，这个问题确实当时没多想，回来之后仔细研究和讨论了下这个问题，对大文件读取做了一个分析 比如我们有一个log文件，运行了几年，有100G之大。按照我们之前的操作可能代码会这样写： func ReadFile(filePath string) []byte{ content, err :=...
面向CSDN编程之：golang逐行读取文件内容
遇见你是我最美丽的意外
01-17 1436
golang逐行读取文件内容 1. 背景 周末花了两天写了一个爬取、并解析HMDB数据库的工具，为了能够根据下载定义HMDB-ID的数据信息，我特意将涉及到的HMDB-ID存储到一个list.txt文件中，然后逐行读取list.txt文件，将读取到的接口拼接完成的URL后进行访问、下载。 文件中可以根据需要放很多ID，几百上千条是没有问题的。 2. 实现 以下代码中创建了很多的gorouting, 通过chan来判断是否结束。不过今天看书，书上说推荐使用WaitGroup变量来解决这种问题。有时间再试试w
GoLang几种读文件方式的比较
webxscan.com
03-13 1120
GoLang提供了很多读文件的方式，一般来说常用的有三种。使用Read加上buffer，使用bufio库和ioutil 库。 那他们的效率如何呢？用一个简单的程序来评测一下：        Go代码   package main    import(      "fmt"      "os"      "flag"      "io"      "io/ioutil"  
Golang读写文件
umgsai的专栏
05-22 756
使用带缓冲区的方式读取文件 package main import ( "bufio" "fmt" "io" "os" ) func main() { file, err := os.Open("/Users/shangyidong/Downloads/test.txt") if err != nil { fmt.Printf("open file error:%v\n", err) return } // 函数结束前关闭文件 defer file.Close() fmt
Go 语言读取文件的几种方式
金戈鐡馬
04-19 1747
本文介绍了 Go 语言读取文件的几种方式，函数将整个文件读成一个字符串。这个函数很方便，但不应该用于非常大的文件。希望能对你有所帮助！
golang文件读写操作
abcnull 的博客
05-29 1027
文章目录 golang 常用输入输出 常用：读取文件成 []byte 一种是生成 File，再利用 File 读或者写；另一种通过 ioutil 包直接对某路径下文件进行读写 // 依据相对路径拿到 *File 类型 jsonFile, err := os.Open(path) defer jsonFile.Close() // 将读取的文件读成 []byte jsonData, err := ioutil.ReadAll(jsonFile) // 通过序列化机制，把 []byte 转成特定结构 struc
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值