目录
文件的基本介绍
- 文件的概念
文件,对我们并不陌生,文件是数据源(保存数据的地方)的一种,比如大家经常使用的word 文档,txt 文件,excel 文件...都是文件。文件最主要的作用就是保存数据,它既可以保存一张图片,也可以保持视频,声音...
- 输入流和输出流
- os.File 封装所有文件相关操作，File 是一个结构体
总结：后面我们操作文件，会经常使用到 os.File 结构体.
打开文件和关闭文件
代码如下：
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)
//关闭文件
err = file.Close()
if err != nil {
fmt.Println("file close err=", err)
}
}
读取文件操作应用
读取文件的内容并显示在终端(带缓冲区的方式)，使用 os.Open, file.Close, bufio.NewReader(),reader.ReadString 函数和方法.
package main
import (
"bufio"
"fmt"
"io"
"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
defer file.Close() //要及时关闭file句柄，否则会有内存泄漏
//创建一个 *Reader ,是带缓冲的
/*
const (
defaultBufSize = 4096 //默认的缓冲区大小为4096
)
*/
reader := bufio.NewReader(file)
//循环的读取文件的内容
for {
str, err := reader.ReadString('\n') //读到一个换行符就结束
fmt.Print(str)
if err == io.EOF { //io.EOF表示文件的末尾
break
}
}
fmt.Println("\n文件读取完毕。。。")
}
- 2
- 读取文件的内容并显示在终端(使用 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",string(content)) // []byte
//我们没有显式的Open文件，因此也不需要显式的Close文件
//因为，文件的Open和Close被封装到ReadFile函数内部
}写文件操作应用
基本介绍--- os.OpenFile函数
第二个参数文件打开模式（可以组合使用）flag
在 os-》Constants 中
第三个参数
写文件基本应用
创建一个新文件，写入内容 5 句 "hello, Gardon"
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
//创建一个新文件，写入内容：5句“hello，Gardon”
//1、打开文件 d:/abc.txt
filePath := "d:/abc.txt"
file ,err := os.OpenFile(filePath,os.O_WRONLY | os.O_CREATE,02)
if err != nil {
fmt.Printf("open file err=%v",err)
return
}
//准备写入5句 "hello,Gardon"
str := "hello,Gardon\n"
//写入时，使用带缓存的 *Writer
writer := bufio.NewWriter(file)
for i:=0;i<5;i++ {
writer.WriteString(str)
}
//因为writer是带缓存的，因此在调用WriteString方法时，其实
//内容是先写入到缓存的，所以需要调用Flush方法，将缓存的数据
//真正写到文件中，否则文件中会没有数据
writer.Flush()
}
打开一个存在的文件中，将原来的内容覆盖成新的内容 10 句 "你好，尚硅谷!"
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
//打开一个存在的文件，将原来的内容覆盖成新的内容 10句 "你好，尚硅谷！"
//1、打开文件已存在 d:/abc.txt
filePath := "d:/abc.txt"
file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_TRUNC, 02)
if err != nil {
fmt.Printf("open file err=%v", err)
return
}
//准备写入5句 "hello,Gardon"
str := "你好，尚硅谷\n"
//写入时，使用带缓存的 *Writer
writer := bufio.NewWriter(file)
for i := 0; i < 10; i++ {
writer.WriteString(str)
}
//因为writer是带缓存的，因此在调用WriteString方法时，其实
//内容是先写入到缓存的，所以需要调用Flush方法，将缓存的数据
//真正写到文件中，否则文件中会没有数据
writer.Flush()
}
若需要进行文件内容覆盖，则需要使用os.O_TRUNC 进行全部内容清空，然后再写入；
- 打开一个存在的文件，在原来的内容追加内容 'ABC! ENGLISH!'
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
//打开一个存在的文件，将原来的内容覆盖成新的内容 10句 "你好，尚硅谷！"
//1、打开文件已存在 d:/abc.txt
filePath := "d:/abc.txt"
file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_APPEND, 02)
if err != nil {
fmt.Printf("open file err=%v", err)
return
}
//准备写入5句 "hello,Gardon"
str := "hello,english\n"
//写入时，使用带缓存的 *Writer
writer := bufio.NewWriter(file)
for i := 0; i < 2; i++ {
writer.WriteString(str)
}
//因为writer是带缓存的，因此在调用WriteString方法时，其实
//内容是先写入到缓存的，所以需要调用Flush方法，将缓存的数据
//真正写到文件中，否则文件中会没有数据
writer.Flush()
}
- 打开一个存在的文件，将原来的内容读出显示在终端，并且追加 5 句"hello,北京!"
package main
import (
"bufio"
"fmt"
"io"
"os"
)
func main() {
//打开一个存在的文件，将原来的内容覆盖成新的内容 10句 "你好，尚硅谷！"
//1、打开文件已存在 d:/abc.txt
filePath := "d:/abc.txt"
file, err := os.OpenFile(filePath, os.O_RDWR|os.O_APPEND, 02)
if err != nil {
fmt.Printf("open file err=%v", err)
return
}
defer file.Close()
//先读取原来的文件内容，并显示在终端
reader := bufio.NewReader(file)
for {
str, err := reader.ReadString('\n')
//显示到终端
fmt.Print(str)
if err == io.EOF {
break
}
}
//准备写入5句 "hello,Gardon"
str := "hello,english\n"
//写入时，使用带缓存的 *Writer
writer := bufio.NewWriter(file)
for i := 0; i < 3; i++ {
writer.WriteString(str)
}
//因为writer是带缓存的，因此在调用WriteString方法时，其实
//内容是先写入到缓存的，所以需要调用Flush方法，将缓存的数据
//真正写到文件中，否则文件中会没有数据
writer.Flush()
}
- 编程一个程序，将一个文件的内容，写入到另外一个文件。注：这两个文件已经存在了. 说明：使用 ioutil.ReadFile / ioutil.WriteFile 完成写文件的任务.
package main
import (
"fmt"
"io/ioutil"
)
func main() {
file1Path := "d:/abc.txt"
file2Path := "d:/123.txt"
res, err := ioutil.ReadFile(file1Path)
if err != nil {
fmt.Println("file read err=", err)
return
}
err = ioutil.WriteFile(file2Path, res, 02)
if err != nil {
fmt.Println("write file err=", err)
}
}
判断文件或目录是否存在
golang判断文件或目录是否存在的方法为：使用os.Stat()函数返回的错误值进行判断：
1）如果返回的错误为nil，说明文件或文件夹存在
2）如果返回的错误类型使用os.IsNotExist()判断为true，说明文件或文件夹不存在
3）如果返回的错误为其他类型，则不确定是否存在
func PathExists(path string) (bool,error){
_, err := os.Stat(path)
if err == nil { //文件或目录存在
return true,nil
}
if os.IsNotExist(err){
return false,nil
}
return false,err
}拷贝文件
说明：将一张图片/电影/mp3 拷贝到另外一个文件 io 包
package main
import (
"bufio"
"fmt"
"os"
"io"
)
// 自己编写一个函数，接收两个文件路径 srcFileName dstFileName
func CopyFile(dstFileName string, srcFileName string) (written int64, err error) {
srcFile, err := os.Open(srcFileName)
if err != nil {
fmt.Println("file open err=", err)
return 0, err
}
defer srcFile.Close()
reader := bufio.NewReader(srcFile)
//打开dstFileName
dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY|os.O_CREATE, 02)
if err != nil {
fmt.Println("open file err=", err)
return
}
writer := bufio.NewWriter(dstFile)
defer dstFile.Close()
return io.Copy(writer, reader)
}
func main() {
//将文件进行拷贝
srcFile := "d:/Videos/Owl CityCarly Rae Jepsen - Good Time.mp4"
dstFile := "d:/ad.mp4"
_, err := CopyFile(dstFile, srcFile)
if err != nil {
fmt.Println("file copy err=", err)
return
}
fmt.Println("文件拷贝完成")
}
扫一扫
1718
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
