（八）文件的操作

最新推荐文章于 2023-11-09 19:30:59 发布
最新推荐文章于 2023-11-09 19:30:59 发布
阅读量458 收藏
点赞数
分类专栏： Golang 文章标签： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_rsq/article/details/106325997
版权

文章目录

1 读取文件

读文件用 os 包，需要注意的是在打开一个文件进行操作后需要及时关闭文件。用几个小例子来说明一下。

1.1 exa1

package main

import (
	"fmt"
	"os"
)

func main()  {

	// 打开一个文件
	// 概念说明：file的叫法
	// 1.file 叫 file对象
	// 2.file 叫 file指针
	// 3.file 叫 file文件句柄
	file, err := os.Open("d:/test.txt")
	if err != nil {
		fmt.Println("Open file err=", err)
	}

	// 输出以下内容可以看出file就是一个指针
	fmt.Printf("file=%v", file)  // 输出file=&{0xc000084780}

	// 关闭文件
	err = file.Close()
	if err != nil {
		fmt.Println("close file err=", err)
	}

}

1.2 exa2

读文件的内容并显示在终端（带缓冲区的方式）使用os.Open(), file.close(), bufio.NewReader(), reader.ReadString函数和方法。

package main

import (
	"fmt"
	"os"
	"bufio"
	"io"
)

func main()  {

	// 打开文件
	file, err := os.Open("d:/test.txt")

	if err != nil {
		fmt.Println("Open file err=", err)
	}

	// 当函数退出时候，要及时关闭文件句柄，否则会有内存泄漏
	defer file.Close()

	// 创建一个带缓冲的 *Reader
	// 默认缓冲区 4096
	reader := bufio.NewReader(file)
	for {
		str, err := reader.ReadString('\n')  // 每读到一个换行就结束一次
		if err == io.EOF {  // io.EOF代表文件的末尾
			break
		}
		// 输出内容
		fmt.Print(str)
	}

	fmt.Println("文件读取结束")
}
// 需要注意的是如果使用 if err == io.EOF ，那么在我们要读取的文件中最后一行一定是一个换行
// 否则不能读取到最后一行

1.3 exa3

读取文件的内容并显示在终端（使用ioutil一次将整个文件读入到内存中）这种方式适用于文件不大的情况，相关方法和函数(ioutil.ReadFile)，此函数封装了打开和关闭的操作

package main

import (
	"fmt"
	"io/ioutil"
)

func main() {

	// 使用 ioutil.ReadFile 一次性将文件读取到位
	file := "d:/test.txt"
	content, err := ioutil.ReadFile(file)
	if err != nil {
		fmt.Printf("read file err = %v", err)
	}

	// 把读取到的内容显示到终端
	fmt.Printf("%v", content)  // []byte 会以byte切片的样式输出
	// 因为没有显式Open，因此也不需要显式的Close文件文件的Open和Close功能都被封装到函数中

	fmt.Printf("%s", content)  // 可以完整将字符串输出
	//fmt.Printf("%v", string(content))
}

1.4 判断文件是否存在

golang中判断文件或文件夹是否存在的方法是使用 os.Stat() 函数返回的错误值进行判断。

package main

import (
	"fmt"
	"os"
)

// 判断文件是否存在
func PathExists(path string) (bool, error) {

	_, err := os.Stat(path)
	if err == nil {  // 如果err为空，则证明文件存在
		return true, nil
	}


	if os.IsNotExist(err) {
		return false, nil
	}
	return false, err

}

func main() {

	filePath := "d:/test.txt"

	b, err := PathExists(filePath)
	if b == true && err == nil {
		fmt.Printf("%v文件存在", filePath)
		return
	}
	fmt.Printf("%v文件不存在", filePath)

}

2 写入文件内容

需要用到 os.OpenFile 函数
func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
说明： os.OpenFile 它会使用指定的选项（如os.o_RDONLY等）、指定的模式（如0666等，此选项只在linux系统中生效），如果成功，则返回的对象可以用于 I/O 操作

2.1 exa1

创建一个新文件，写入内容 5 句 “hello, Gardon”

package main

import (
	"fmt"
	"bufio"
	"os"
)

func main() {

	// 创建一个新文件，写入内容 5 句 "hello, Gardon"
	// 1.打开文件 d:/abc.txt
	filePath := "d:/abc.txt"
	file, err := os.OpenFile(filePath, os.O_CREATE | os.O_WRONLY, 0666)
	if err != nil {
		fmt.Printf("open file err = %v", err)
		return
	}

	// 准备写入5句话
	str := "hello, Gardon\r\n" // 表示换行
	writer := bufio.NewWriter(file)
	for i := 0; i < 5; i++ {
		writer.WriteString(str)
	}

	// 及时关闭file句柄
	defer file.Close()

	// 因为writer是带缓存，因此在调用WriteString方法时
	// 其实内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据真正写入到文件中，
	// 否则文件中会没有数据
	writer.Flush()
}

2.2 exa2

打开一个已经存在的文件，将原来的内容覆盖成新的内容10句 “你好，我是老大”

package main

import (
	"fmt"
	"bufio"
	"os"
)

func main() {

	// 打开一个已经存在的文件，将原来的内容覆盖成新的内容10句 "你好，我是老大"
	// 1.打开文件 d:/abc.txt
	filePath := "d:/abc.txt"
	file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_TRUNC , 0666)
	if err != nil {
		fmt.Printf("open file err = %v", err)
		return
	}

	// 及时关闭file句柄
	defer file.Close()

	// 写入10句 "你好，我是老大"
	str := "你好，我是老大\r\n" // 表示换行
	writer := bufio.NewWriter(file)
	for i := 0; i < 10; i++ {
		writer.WriteString(str)
	}

	writer.Flush()
}

2.3 exa3

打开一个存在的文件，在原来的内容追加内容 'ABC!ENGHSK’

package main

import (
	"fmt"
	"bufio"
	"os"
)

func main() {

	// (3)打开一个存在的文件，在原来的内容追加内容 'ABC!ENGHSK'
	filePath := "d:/abc.txt"
	file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_APPEND , 0666)
	if err != nil {
		fmt.Printf("open file err = %v", err)
		return
	}

	// 及时关闭file句柄
	defer file.Close()

	// 写入10句 'ABC!ENGHSK'
	str := "'ABC!ENGHSK'\r\n" // 表示换行
	writer := bufio.NewWriter(file)
	for i := 0; i < 10; i++ {
		writer.WriteString(str)
	}

	writer.Flush()
}

2.4 exa4

打开一个存在的文件，将原来的内容读出显示在终端，并且追加5句"hello, 北京"

package main

import (
	"fmt"
	"bufio"
	"os"
	"io"
)

func main() {

	// (4)打开一个存在的文件，将原来的内容读出显示在终端，并且追加5句"hello, 北京"
	filePath := "d:/abc.txt"
	file, err := os.OpenFile(filePath, os.O_RDONLY | os.O_APPEND , 0666)
	if err != nil {
		fmt.Printf("open file err = %v", err)
		return
	}

	// 及时关闭file句柄
	defer file.Close()

	// 先读取原来的内容
	reader := bufio.NewReader(file)
	for {
		str, err := reader.ReadString('\n')
		if err == io.EOF {
			break
		}
		// 显示到终端
		fmt.Print(str)
	}

	// 写入10句 "hello, 北京"
	str := "hello, 北京\r\n" // 表示换行
	writer := bufio.NewWriter(file)
	for i := 0; i < 5; i++ {
		writer.WriteString(str)
	}

	writer.Flush()
}

2.5 exa5

编写一个程序，将一个文件的内容写入到另一个文件。这两个文件已经存在

package main

// 编写一个程序，将一个文件的内容写入到另一个文件。这两个文件已经存在
// 使用ioutil.ReadFile / ioutil.WriteFile

import (
	"fmt"
	"io/ioutil"
)

func main() {

	// 将d:/abc.txt文件内容导入到 f:/kkk.txt
	// 声明两个文件名
	file1Path := "d:/abc.txt"
	file2Path := "f:/kkk.txt"

	// 1.将d:/abc.txt内容读取到内存
	content, err := ioutil.ReadFile(file1Path)
	if err != nil {
		// 说明文件读取有错误
		fmt.Printf("read file err = %v\n", err)
		return
	}

	// 2.将读取到的内容写入到 f:/kkk.txt
	err = ioutil.WriteFile(file2Path, content, 0666)
	if err != nil {
		fmt.Printf("write file error = %v\n", err)
	}

}

3 文件的拷贝

3.1 拷贝非文本文件的文件

package main

import (
	"fmt"
	"os"
	"io"
	_ "io/ioutil"
	"bufio"
)

// 将一张图片/电影/mp3文件拷贝到另一个文件中 需要用到io包（注意不是文本文件）
// io.Copy

// 编写一个函数，接收两个文件路径 srcFileName dstFileName
func CopyFile(dstFileName string, srcFileName string) (written int64, err error) {
	srcfile, err := os.Open(srcFileName)
	if err != nil {
		fmt.Printf("Open file err = %v", err)
	}
	defer srcfile.Close()

	//通过srcfile句柄获取到 Reader
	reader := bufio.NewReader(srcfile)

	// 打开dstFileName（由于这个文件可能不存在，所以不能用os.Open来打开）
	dstFile, err := os.OpenFile(dstFileName, os.O_CREATE | os.O_WRONLY, 0666)
	if err != nil {
		fmt.Printf("open file err = %v", err)
		return
	}

	// 通过dstFile，获取到writer
	writer := bufio.NewWriter(dstFile)
	defer dstFile.Close()

	return io.Copy(writer, reader)
}

func main() {

	// 将 d:/flower.jpg 拷贝到 f:/abc.jpg

	// 调用CopyFile完成文件的拷贝
	srcFile := "d:/flower.jpg"
	dstFile := "f:/abc.jpg"

	_, err := CopyFile(dstFile, srcFile)
	if err == nil {
		fmt.Println("Copy Successd!")
	} else {
		fmt.Println("Copy error info = %v", err)
	}
}

3.2 拷贝文本文件

package main

import (
	"fmt"
	"os"
	"io"
	_ "io/ioutil"
	"bufio"
)

// 将文本文件拷贝到另一个文件中 需要用到io包，
// io.Copy

// 编写一个函数，接收两个文件路径 srcFileName dstFileName
func CopyFile(dstFileName string, srcFileName string) (written int64, err error) {
	srcfile, err := os.Open(srcFileName)
	if err != nil {
		fmt.Printf("Open file err = %v", err)
	}
	defer srcfile.Close()

	//通过srcfile句柄获取到 Reader
	reader := bufio.NewReader(srcfile)


	// 打开dstFileName（由于这个文件可能不存在，所以不能用os.Open来打开）
	dstFile, err := os.OpenFile(dstFileName, os.O_CREATE | os.O_WRONLY, 0666)
	if err != nil {
		fmt.Printf("open file err = %v", err)
		return
	}

	// 通过dstFile，获取到writer
	writer := bufio.NewWriter(dstFile)

	// 循环把src读取的每行数据写入到writer
	for {
		str, err := reader.ReadString('\n')
		if err == io.EOF {  // io.EOF代表文件的末尾
			break
		}
		// 显示到终端
		writer.WriteString(str)
	}

	// flush把缓冲的数据写入到真实文件中
	writer.Flush()
	defer dstFile.Close()

	return io.Copy(writer, reader)
}

func main() {

	// 将 d:/flower.txt 拷贝到 f:/abc.txt

	srcFile := "d:/flower.txt"
	dstFile := "f:/abc.txt"

	_, err := CopyFile(dstFile, srcFile)
	if err == nil {
		fmt.Println("Copy Successd!")
	} else {
		fmt.Println("Copy error info = %v", err)
	}
}

4 命令行参数

如果希望获取到命令行输入的各种参数，可以使用os.Args，它是一个string切片，用来存储所有的命令行参数

4.1 exa1

package main

import (
	"fmt"
	"os"
)

func main() {

	fmt.Println("命令行的参数有", len(os.Args))
	for i, v := range os.Args {
		fmt.Printf("args[%v]=%v\n", i, v)
	}

	/*
	D:\goproject\src\go_code\file\commandLineArgs>main.exe D:\goproject\src\go_code 99
	命令行的参数有 3
	args[0]=main.exe
	args[1]=D:\goproject\src\go_code
	args[2]=99
	*/
}

4.2 exa2 (flag)

golang中可以用flag包来解析命令行参数，exa1中使用的 os.Args 来获取命令行参数比较原生，解析不是特别方便，尤其是带有指定参数形式的命令行

package main

import (
	"fmt"
	"flag"
)

func main() {

	// 定义几个变量，用于接收命令行输入的参数值
	var user string
	var pwd string
	var host string
	var port int

	// &user 就是用来接收用户命令行中输入的 -u 后面的参数值
	// "u" 就是 -u 指定参数
	// "" 默认值
	// "用户名，默认为空" 对此参数的说明
	flag.StringVar(&user, "u", "", "用户名，默认为空")
	flag.StringVar(&pwd, "pwd", "", "密码，默认为空")
	flag.StringVar(&host, "h", "localhost", "主机名，默认为localhost")
	flag.IntVar(&port, "port", 3306, "端口，默认为3306")

	// 这里有一个非常重要的操作，转换  必须调用该方法
	flag.Parse()

	// 输出结果
	fmt.Printf("user=%v pwd=%v host=%v port=%v",
		user, pwd, host, port)
	/*
	可以不用指定顺序
	D:\goproject\src\go_code\file\commandLineArgs\flag>go build -o flag.exe main.go
	D:\goproject\src\go_code\file\commandLineArgs\flag>flag.exe -u root -pwd 12335465 -h 192.168.0.1 -port 8080
	user=root pwd=12335465 host=192.168.0.1 port=8080

	默认值
	D:\goproject\src\go_code\file\commandLineArgs\flag>flag.exe -u root -pwd 12335465
	user=root pwd=12335465 host=localhost port=3306

	*/
}
RSQ博客
关注
专栏目录
Python程序设计 第8章：文件操作
惊鸿若梦一书生
04-10 3618
Python程序设计 第8章：文件操作8.1 文件对象8.1.1 打开文件8.1.2 关闭文件8.1.3 文件对象的属性8.1.4 文件对象的方法8.2 文件系统访问8.2.1 os模块8.2.2 文件路径操作8.3 文件数据处理8.3.1 按字节处理数据8.3.2 使用文件迭代器8.3.3 结构化数据存储8.3.4 序列化存储8.4 综合案例8.5 总结 8.1 文件对象 8.1.1 打开文件 8.1.2 关闭文件 8.1.3 文件对象的属性 8.1.4 文件对象的方法 8.2 文件系统访问 8.2.1
13将Hello! I‘m writing to this file!写入到/tmp/hello.c文件中,并再读出前10个字符,输出到屏幕上
weixin_58621185的博客
07-03 250
【代码】13将Hello!写入到/tmp/hello.c文件中,并再读出前10个字符,输出到屏幕上。
Linux文件操作
xingnong的专栏
08-15 1166
1. 理解文件描述符 1.1 文件描述符的概念        文件描述符是个很小的正整数，它是一个索引值，指向内核为每一个进程所维护的该进程打开文件的记录表。例如，每个进程启动时都会打开3个文件：标准输入、标准输出和标准错误文件。这3个文件分别对应于文件描述符0、1和2。
文件的读写基本操作
热门推荐
范高伦的博客
09-07 1万+
一、文件是计算机中数据持久化存储的表现形式 读写文件标准操作格式1： 1、打开文件：file1 = open('文件名','读写模式') 2、操作文件 3、关闭文件：file1.close() 文件操作完毕后必须关闭，否则长期保持对文件的连接状态，造成内存溢出的现象发生 读写文件操作格式2： # 1、打开文件 file1 = open('demo.txt','w') # 2、操作文件 file1.write('hello world') # 3、关闭文件 file1.close() 1、打开文件：wi
Python实验项目6 ：文件操作与模块化
m0_63949203的博客
11-09 865
Python实验项目6 ：文件操作与模块化
os.system()报错：Path %!s(＜nil＞) does not exist.（成功解决）
qq_43574741的博客
05-23 825
代码块： import os exe0 = 'ncm_to_mp3.exe' song = 'May It Be.ncm' r_v = os.system("%s %s"%(exe0,song)) print(r_v) 就是想通过python的os库里面的system调用exe文件：ncm_to_mp3，并且输入也为一个文件：May It Be.ncm。 路径使用的是相对路径，就把exe与ncm都拉到py文件所在目录下。 结果一直给我报错： 解决方法： 尝试很多遍，发现是因为文件名有空格，因为syste
实验八 文件操作与异常处理.md
11-19
实验八 文件操作与异常处理.md
操作系统实验八 文件管理
06-13
采用二级文件目录结构，编写程序实现文件系统的文件存储空间的管理、文件的物理结构、目录结构管理和文件操作。 三、实验要求 1、设计一个有m个用户的文件系统，每个用户最多可保存一个文件。 2、规定用户在一次...
操作系统第八章文件管理
最新发布
01-17
操作系统第八章文件管理
操作系统第八章实验——文件管理
05-13
"structure,h" "creat.h" "access.h" "ballfre.h" "close.h" "delete.h" "dir.h" "format.h" "halt.h" "iallfre.h" "install.h" "log.h" "name.h" "open.h" "rdwt.h" "igetput.h
matlab开发-RSQ工具箱格式实验室
08-26
matlab开发-RSQ工具箱格式实验室。大规模等式约束优化工具箱，一种RSQP算法的实现。
Go对文件操作
weixin_39218464的博客
04-23 518
目录 文件读写 文件读操作 1）文件打开与关闭 简易方式打开一个文件，对文件操作，一秒后关闭 package main import ( "fmt" "os" "time" ) func main() { file, err := os.Open("D:/go_work/src/demo/1.json") if err == nil { fmt.Println("文件打开成功") } else { fmt.Println("文件打开失败，err=", err) return
C语言：编写一个程序，建立一个abc.txt文本文件，向其中写入“this is a test”,然后显示该字符串
小七月的博客
03-31 6737
/*编写一个程序，建立一个abc.txt文本文件，向其中写入“this is a test”,然后显示该字符串*/ #include <stdio.h> #include <string.h> { FILE* fp; char str[30]="this is a test!",buf[20]; str[strlen(str)]=0;//置0结束标志,防止写入多余字符...
Linux 基础上机篇
qq_48496633的博客
11-08 6338
目录 第一次上机： 第二次上机： 第三次上机： 第四次上机： 第一次上机： 1,查看当前在线用户，以及工作目录。 w #查看当前在线用户 pwd #查看工作目录 2，使用命令date显示当前的时间和日期；将现在日期按照格式：时：分：秒 年-月-日显示。（并将显示结果存入/home/shouyi/a文件中，并查看文件内容。） date +'%H:%M:%S %y/%m/%d' #以时：分：秒 年-月-日显示当前时间。..
C语言中的文件处理—如何打开，关闭和写入文件
08-15 506
If you’ve written the C helloworld program before, you already know basic file I/O in C: 如果您以前编写过C helloworld程序，那么您已经知道C中的基本文件I / O： /* A simple hello world in C. */ #include <stdlib.h> // Imp...
Go语言学习笔记(十八)之文件读写
weixin_30505043的博客
01-05 87
25.文件读写 1.文件打开和读 A.文件分类：文本和二进制文件B.文件存取方式：随机存取和顺序存取 文件打开代码示例： 1: package main 2: 3: import ( 4: "bufio" 5: "fmt" 6: "io" 7: "os" 8: ) 9: 10: func main() { 11: //只读的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

RSQ博客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值