Golang学习笔记-文件读取写入字符串

最新推荐文章于 2023-07-13 00:29:33 发布
最新推荐文章于 2023-07-13 00:29:33 发布
阅读量1.5k 收藏 3
点赞数 3
分类专栏： GO学习笔记 文章标签： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35825178/article/details/108892201
版权

文章目录

文件读取

1.使用 ioutil.ReadFile 直接从文件读取
// ReadFileMethod1 使用ioutil.ReadFile 直接从文件读取到 []byte中
func ReadFileMethod1(fileName string) string {
	f, err := ioutil.ReadFile(fileName)
	if err != nil {
		log.Printf("读取文件失败:%#v", err)
		return ""
	}
	return string(f)
}
2.使用ioutil.ReadAll 将 file 直接读取
// ReadFileMethod2 读取到 file 中，再利用 ioutil 将 file直接读取到 []byte 中
func ReadFileMethod2(fileName string) string{
    f, err := os.Open(fileName)
    if err != nil {
        log.Printf("打开文件失败:%#v", err)
        return ""
    }
    defer f.Close()
    fd, err := ioutil.ReadAll(f)
    if err != nil {
        log.Printf("ioutil 读取文件失败:%#v", err)
        return ""
    }
    return string(fd)
}
3.打开文件，读取到缓冲区，从缓冲区获取信息
// ReadFileMethod3 从文件读取到file中，在从file读取到buf, buf在追加到最终的[]byte
func ReadFileMethod3(fileName string) string {
	// 打开文件
	f, err := os.Open(fileName)
	if err != nil {
		log.Printf("read fail")
		return ""
	}
	// 把获取的file数据读取到缓冲区中
	defer f.Close()
	var dataBlock []byte
	buf := make([]byte, 102400)
	for {
		// 从file读取到buf中
		n, err := f.Read(buf)
		if err != nil {
			if err == io.EOF{
				// 判断文件读取结束
				break
			} 
			log.Printf("读取缓冲数据失败:%#v", err)
			return ""
		}
		// 读取到最终的缓冲区中
		dataBlock = append(dataBlock, buf[:n]...)
	}
	return string(dataBlock)
}
4.文件读取到file然后到Reader中，从Reader读取到缓冲区
// ReadFileMethod4 先从文件读取到file, 在从file读取到Reader中，从Reader读取到buf, buf最终追加到[]byte，这个排第三
func ReadFileMethod4(fileName string) string {
	f, err := os.Open(fileName)
	if err != nil {
		log.Printf("打开文件失败:%#v", err)
	}
	defer f.Close()
	r := bufio.NewReader(f)
	var dataBlocks []byte
	buf := make([]byte, 102400) // 每次读取字节数
	for {
		n, err := r.Read(buf)  // 读取字节数 n 
		if err != nil {
			if err == io.EOF {
				// 判断文件读取结束
				break
			}
			log.Printf("打开文件失败:%#v", err)
		}
		dataBlocks = append(dataBlocks, buf[:n]...) // 注意有人这里[:n] 是读的字节数赋值，最后一次读取可能小于buf定义量
	}
	return string(dataBlocks)
}
对比读取耗时
func main() {
	startTime := time.Now()

	stringFile1 := ReadFileMethod1("test.dat")
	endMethod1Time := time.Now()

	stringFile2 := ReadFileMethod2("test.dat")
	endMethod2Time := time.Now()

	stringFile3 := ReadFileMethod3("test.dat")
	endMethod3Time := time.Now()
	
	stringFile4 := ReadFileMethod4("test.dat")
	endMethod4Time := time.Now()

	log.Printf("ReadFileMethod1 读取文件内容字节长度: %d  耗时: %s", len(stringFile1), endMethod1Time.Sub(startTime).String())
	log.Printf("ReadFileMethod2 读取文件内容字节长度: %d  耗时: %s", len(stringFile2), endMethod2Time.Sub(endMethod1Time).String())
	log.Printf("ReadFileMethod3 读取文件内容字节长度: %d  耗时: %s", len(stringFile3), endMethod3Time.Sub(endMethod2Time).String())
	log.Printf("ReadFileMethod4 读取文件内容字节长度: %d  耗时: %s", len(stringFile4), endMethod4Time.Sub(endMethod3Time).String())
}
/* 本机对比
2020/09/30 00:38:41 ReadFileMethod1 读取文件内容字节长度: 56503278  耗时: 73.957ms
2020/09/30 00:38:41 ReadFileMethod2 读取文件内容字节长度: 56503278  耗时: 97.9476ms
2020/09/30 00:38:41 ReadFileMethod3 读取文件内容字节长度: 56503278  耗时: 95.9469ms
2020/09/30 00:38:41 ReadFileMethod4 读取文件内容字节长度: 56503278  耗时: 80.9536ms
*/

文件处理

1.判断文件是否存在
2.文件不存在就创建文件
// IsExists 判断所给路径文件/文件夹是否存在
func IsExists(path string) bool {
	_, err := os.Stat(path) //os.Stat获取文件信息
	if err != nil && !os.IsExist(err) {
		return false
	}
	return true
}

// IfNoFileToCreate 文件不存在就创建文件
func IfNoFileToCreate(fileName string) (file *os.File) {
	var f *os.File
	var err error
	if !IsExists(fileName) {
		f, err = os.Create(fileName)
		if err != nil {
			return
		}
		log.Printf("IfNoFileToCreate 函数成功创建文件:%s", fileName)
		defer f.Close()
	}
	return f
}

文件写入

1. ioutil.WriteFile 写入文件
// WriteStringToFileMethod1 通过 ioutil.WriteFile 写入文件
func WriteStringToFileMethod1(fileName string, writeInfo string) {
	_ = IfNoFileToCreate(fileName)
	info := []byte(writeInfo)
	if err := ioutil.WriteFile(fileName, info, 0666); err != nil {
		log.Printf("WriteStringToFileMethod1 写入文件失败:%+v", err)
		return
	}
	log.Printf("WriteStringToFileMethod1 写入文件成功")
}
2. io.WriteString 写入文件
// WriteStringToFileMethod2 通过 io.WriteString 写入文件
func WriteStringToFileMethod2(fileName string, writeInfo string) {
	_ = IfNoFileToCreate(fileName)
	f, err := os.OpenFile(fileName, os.O_APPEND, 0666) //打开文件
	defer f.Close()
	if err != nil {
		log.Printf("打开文件失败:%+v", err)
		return
	}
	// 将文件写进去
	if _, err = io.WriteString(f, writeInfo); err != nil {
		log.Printf("WriteStringToFileMethod2 写入文件失败:%+v", err)
		return
	}
	log.Printf("WriteStringToFileMethod2 写入文件成功")
}
3. file.Write(WriteString) 写入文件
// WriteStringToFileMethod3  通过 File(Write,WriteString) 写入文件
func WriteStringToFileMethod3(fileName string, writeInfo string) {
	_ = IfNoFileToCreate(fileName)
	f, err := os.OpenFile(fileName, os.O_APPEND, 0666) //打开文件
	defer f.Close()
	if err != nil {
		log.Printf("打开文件失败:%+v", err)
		return
	}	
	info := []byte(writeInfo)
	// 写入文件
    if _, err = f.Write(info); err != nil {
        log.Printf("WriteStringToFileMethod3 写入文件失败:%+v", err)
		return
	}
	log.Printf("WriteStringToFileMethod3 写入文件成功")
}
4. bufio.NewWriter 写入文件
// WriteStringToFileMethod4  通过 bufio.NewWriter 写入文件
func WriteStringToFileMethod4(fileName string, writeInfo string) {
	_ = IfNoFileToCreate(fileName)
	f, err := os.OpenFile(fileName, os.O_APPEND, 0666) //打开文件
	defer f.Close()
	if err != nil {
		log.Printf("打开文件失败:%+v", err)
		return
	}	
	// 创建 Writer 对象
	w := bufio.NewWriter(f) 
	// 写入文件
    if _, err = w.WriteString(writeInfo); err != nil {
        log.Printf("WriteStringToFileMethod4 写入文件失败:%+v", err)
		return
	}
	defer w.Flush()
	log.Printf("WriteStringToFileMethod4 写入文件成功")
}
对比写入耗时
    startWriteTime := time.Now()
	WriteStringToFileMethod1("WriteStringToFileMethod1.dat", stringFile1)
	endWriteMethod1Time := time.Now()

	WriteStringToFileMethod2("WriteStringToFileMethod2.dat", stringFile1)
	endWriteMethod2Time := time.Now()

	WriteStringToFileMethod3("WriteStringToFileMethod3.dat", stringFile1)
	endWriteMethod3Time := time.Now()

	WriteStringToFileMethod4("WriteStringToFileMethod4.dat", stringFile1)
	endWriteMethod4Time := time.Now()

	log.Printf("WriteStringToFileMethod1 文件写入内容字节长度: %d  耗时: %s", len(stringFile1), endWriteMethod1Time.Sub(startWriteTime).String())
	log.Printf("WriteStringToFileMethod2 文件写入内容字节长度: %d  耗时: %s", len(stringFile1), endWriteMethod2Time.Sub(endWriteMethod1Time).String())
	log.Printf("WriteStringToFileMethod3 文件写入内容字节长度: %d  耗时: %s", len(stringFile1), endWriteMethod3Time.Sub(endWriteMethod2Time).String())
    log.Printf("WriteStringToFileMethod4 文件写入内容字节长度: %d  耗时: %s", len(stringFile1), endWriteMethod4Time.Sub(endWriteMethod3Time).String())
    
/*本机性能较差，测试数据较少
2020/10/01 00:47:24 WriteStringToFileMethod1 文件写入内容字节长度: 1975492  耗时: 3.9996ms
2020/10/01 00:47:24 WriteStringToFileMethod2 文件写入内容字节长度: 1975492  耗时: 3.0011ms
2020/10/01 00:47:24 WriteStringToFileMethod3 文件写入内容字节长度: 1975492  耗时: 4.9926ms
2020/10/01 00:47:24 WriteStringToFileMethod4 文件写入内容字节长度: 1975492  耗时: 4.9975ms
*/
云之君兮鹏
关注
专栏目录
Go 学习笔记（31）— 字符串 string、字符 rune、字节 byte、UTF-8 和 Unicode 区别以及获取字符串长度
wohu1104的专栏
05-18 7712
1. 字符串 string 类型 Go 语言中字符串的内部实现使用 UTF-8 编码，通过 rune 类型，可以方便地对每个 UTF-8 字符进行访问。当然， Go 语言也支持按照传统的 ASCII 码方式逐字符进行访问。 字符串是常量，可以通过类似数组索引访问其字节单元，但是不能修改某个字节的值； var a string = "hello,world" b := a[0] a[1] = "a" // error 内置的 len 函数可以返回一个字符串中的字节数目（不是 rune 字符数目）
学习笔记 Golang 写入文件（io.WriteString、ioutil.WriteFile、file.Write、write.WriteString）
segegefe的博客
07-31 1677
*信息，如果写入失败，返回error信息，使用ioutil.WriteFile写文件，在写入文件之前，我们不需要判断文件是否存在，如果文件不存在，会自动创建文件，如果文件存在，则会覆盖原来的内容。**信息，在写入文件之前，我们需要判断文件是否存在，如果文件不存在，则需要创建文件。使用此方法在写入文件之前，我们需要判断文件是否存在，如果文件不存在，则需要创建文件。使用此方法在写入文件之前，我们需要判断文件是否存在，如果文件不存在，则需要创建文件。使用file.Write方法写文件，接受的**...
golang将字符串写到文件中
遇见你是我最美丽的意外
10-16 881
func writeLog(msg string) { lock.Lock() defer lock.Unlock() fileHandle, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666) if err != nil { log.Println("open file error :", err) return } defer fileHandle.Close() // NewWriter 默认
go 读取整个文件内容到string变量（How can I read a whole file into a string variable）
wzb56的资料库
10-24 5077
  go 读取整个文件内容到string变量（How can I read a whole file into a string variable） Use ioutil.ReadFile: func ReadFile(filename string) ([]byte, error) ReadFile reads the file named by filename and retur...
如何在Go中将整个文件内容读取为字符串？
cuma2369的博客
07-23 1996
How to read the whole file content into a string in Go? 如何在Go中将整个文件内容读取为字符串 ？ You can use the ReadFile() func from the io/ioutil package in Go to read the whole file content: 您可以使用Go的io/ioutil 包中的Rea...
Go语言核心之美 2.5－字符串
Sunface撩技术
03-17 8558
字符串是不可变的字节序列，可以包含任意数据，包括0这个字节，不过通常是用来包含可读性较强的文本。文本字符串通常采用UTF-8编码，由Unicode码点(rune)组成。 内置的len函数会返回字符串的所有字节数(注意不是rune的数目！！一个rune可能包含多个字节)，下标操作s[i]可以获取字符串的第i 个字节(从0开始),   其中i >= 0 && i s := "hello, world"
golang写入字符串文件
qq_40880022的博客
04-18 1075
package main import ( "bufio" "fmt" "os" ) // 一次性写入所有文件 func writeAllFile() { // 要写入的文件地址和名称 index.html filePath := "/write/index.html" // 要写入的文件内容 content := `<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8".
golang 学习（三十一）文件的读取和写入
wangyufeng43400141的专栏
07-20 454
文件的读取和写入 文件的读取操作 打开和关闭文件 os.Open() 函数能够打开一个文件，返回一个*File 和一个 err。操作完成文件对象以后一定要记得关闭文件 import ( "fmt" "os" ) func TestOpenFile(t *testing.T) { //以只读方式打开文件 fp, err := os.Open("F:/test.txt") if err!=nil{ fmt.Println("打开文件失败") } fmt.Println(fp)//&{0xc
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 文件读写
qq_40771567的博客
09-09 125
话不多说，上代码 package main import ( "bufio" "fmt" "io" "os" ) func main() { //读文件 file, err := os.Open("./test.txt") defer file.Close() if err != nil { fmt.Println("open file error,err:", err) return } reader := bufio.NewReader(file) for { .
GoLang之读取文件10种的方法
weixin_52690231的博客
02-21 2万+
读取文件的 10 种方法
golang的文件读写操作
最新发布
weixin_44684942的博客
07-13 1169
golang的io的一些基本操作
golang 的文件写入和读取（Write()、WriteString()，bufio包：WriteString()、flush()， ioutil 包：WriteFile()、ReadFile()）
运维玄德公
05-05 3480
1. os包 1.1 Write()/WriteString()方法 1.2 Read()方法 2. bufio包 2.1 WriteString()/flush()方法 2.2 ReadLine()方法 3. ioutil 包 3.1 WriteFile() 3.2 ReadFile()
Go语言--字符串的使用
yunfan
09-07 2615
一 字符串类型 字符串在Go语言中是以原生数据类型出现的，使用字符串就像使用其他基本类型(int、bool、float32、float64等)一样。Go语言中，使用关键字string来声明字符串变量。 字符串的值为双引号中的内容，可以在Go语言的源码中直接添加非ASCII码字符。示例代码如下： str := "Hello, Golang" ch := "中文" 1.1 字符串转义符 Go语言的字符串转义符和其他编程语言的是一样，如：回车、换行、单双引号、制表符等。 转义符 含义 ..
golang学习笔记（进阶篇）
lcynone的博客
01-13 921
Golang学习笔记_进阶篇
Java-String
Just__2009的博客
09-07 1833
任何字符串都是String类的对象，字符串是不变的，它们的值在创建后无法更改 在字符串的内部，是用一串字符char[]来存储的。因为数组一经确定长度无法更改，所以字符串一经创建就无法更改。 如果两个字符串内容相同，则他俩使用同一个内存地址，所以可以共享它们 public class Demo2 { public static void main(String[] args) { String s1 = "123"; String s2 = "123"; St
golang中获取字符串长度的几种方法
热门推荐
skh2015java的博客
11-21 5万+
一、获取字符串长度的几种方法 - 使用 bytes.Count() 统计 - 使用 strings.Count() 统计 - 将字符串转换为 []rune 后调用 len 函数进行统计 - 使用 utf8.RuneCountInString() 统计 例： str:="HelloWord" l1:=len([]rune(str)) l2:=bytes.Count([]b
golang获取字符串的某一段的字符
ens160的博客
06-24 2421
package main import ( "fmt" "strings" ) func main() { tracer := "死神来了,死神byebye" comma := strings.Index(tracer, ",") pos := strings.Index(tracer[comma:], "死神") fmt.Println(comma, pos, tracer[comma+pos:]) } 尝试在tracer的字符串中搜索中文的逗号，返回的位置存在comma变量中，类.
Golang文件写入的四种方式
Gcaptain
06-03 1万+
文章目录1. 简单覆盖式文件写入2. 常规文件写入3. 带有缓冲区的文件写入4. 复制操作的文件写入 Golang 中关于文件写入的方法很多 简单覆盖式文件写入 常规文件写入 带有缓冲区的文件写入 复制操作的文件写入 1. 简单覆盖式文件写入 特点 : 操作简单一个函数完成数据写入 新内容覆盖旧的内容 操作的文件不存在的时候会自动创建 使用Golang的标准包 io/ioutil 函数参数说明 : filename 操作的文件名 data 写入的内容 perm 文件不存在时创建文件并赋予的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值