云社区 博客 博客详情

Go文件操作

future 发表于 2020-06-06 19:41:48 2020-06-06
0
0

【摘要】 目录示例1:打开和关闭文件示例2:打开文件并读取内容示例3:一次性读取文件示例4:带缓冲的Reader读文件示例5:创建文件并写入内容示例6:写文件的四种方式示例7:把一个文件内容写入到另一个文件示例8:使用bufio获取用户输入示例9:判断文件或目录是否存在示例10:拷贝文件、图片音视频示例11:遍历目录遍历目录仅遍历目录,忽略文件示例12:修改文件名示例13:创建目录示例1...

对于文件,我们并不陌生,文件是数据源(保存数据的地方)的一种,比如大家经常使用的word文档,txt文件,Excel文件...等等都是文件。文件最主要的作用就是保存数据,它既可以保存一张图片,也可以保存视频,声音......
文件在程序中是以流的形式来操作的。

:数据在数据源(文件)和程序(内存)之间经历的路径
输出流:数据从程序(内存)到数据源(文件)的路径
输入流:数据从数据源(文件)到程序(内存)的路径
输入与输出都是相对于内存而言的,从内存向外流就是输出,从外部向内存流就是输入

在Go中,我们操作文件的方法在os包中,会经常使用到os.File结构体 Go语言标准库文档

示例1: 打开和关闭文件

package main

import (
    "fmt"
    "os"
)

func main() {

    //打开文件(/Users/xxx/Go/src/file.txt)
    //概念说明:file的叫法
    //1.file 叫 file对象
    //2.file 叫 file指针
    //3.file 叫 file文件句柄
    file, err := os.Open("/Users/itbsl/Go/src/file.txt")
    if err != nil {
        fmt.Println("文件打开失败,原因是:", err)
        //os.Exit(0)
    }
    defer func() {
        //文件及时关闭
        err = file.Close()
        if err != nil {
            fmt.Println("文件关闭失败,原因是", err)
        }
    }()
}

示例2: 打开文件并读取内容

使用Read()函数按照字节读

package main

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

func main() {

	file, err := os.Open("./test.txt")
	if err != nil {
		fmt.Printf("open file failed, err:%v\n", err)
		return
	}
	defer func() {
		err = file.Close()
		if err != nil {
			fmt.Printf("close file failed, err:%v\n", err)
		}
	}()

	var content []byte
	var tmp = make([]byte, 128)
	for {
		n, err := file.Read(tmp)
		//为什么是tmp[:n]而不是tmp[:]?
		//因为当读取到最后一行的内容长度不足tmp的长度的时候
		//新读取的内容只会覆盖前半部分上次读取到的tmp的内容,
		//后半部分还是上一次读取的内容,如果用tmp[:]就会导致
		//后半部分久内容又会被重新赋值一次,这其实是错误的
		content = append(content, tmp[:n]...)
		if err == io.EOF {//读到文件末尾
			break
		}
	}
	fmt.Printf("读取出来的内容为:\n")
	fmt.Printf("%q\n", string(content))
}

示例3: 一次性读取文件

读取文件内容并显示在终端,将文件内容一次性读取到终端,适用于文件不大的情况。

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {

    //打开文件,文件路径相对于GOPATH开始,或者写全路径(/Users/xxx/Go/src/file.txt)
    file, err := ioutil.ReadFile("src/file.txt")
    if err != nil {
        fmt.Println("文件打开失败,原因是:", err)
    }

    fmt.Printf("%s", string(file))
}

示例4: 带缓冲的Reader读文件

读取文件的内容并显示在终端(带缓冲区的方式),使用os.Open, file.Close,bufio.NewReader,reader.ReadString函数和方法。适合读取大文件
1.使用ReadBytes方法
代码1:

package main

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

func main() {

	file, err := os.Open("./test.txt")
	if err != nil {
		log.Fatalf("open file failed, err: %v\n", err)
	}
	defer func() {
		err = file.Close()
		if err != nil {
			log.Fatalf("close file failed, err: %v\n", err)
		}
	}()

	//定义变量result用来存储读取结果
	var result string
	//创建一个带有缓冲区的reader
	reader := bufio.NewReader(file)
	for {
		buf, err := reader.ReadBytes('\n')
		if err != nil && err == io.EOF { //EOF代表文件的末尾
			//注意:为什么要判断err是否等于io.EOF?
			//因为存在这种情况,文件有内容的最后那一行尾部没有换行
			//当使用ReadBytes或者ReadString方法按照'\n'换行读取时,读到尾部没有换行的这种情况时就会报io.EOF错误
			//此时buf是读取到了内容的,如果忽略掉了,那么最终的读取结果会少了最后一行的内容
			result += string(buf)
			break
		}
		result += string(buf)
	}
	fmt.Println(result)
}

代码2:

package main

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

func main() {

	file, err := os.Open("./test.txt")
	if err != nil {
		log.Fatalf("open file failed, err: %v\n", err)
	}
	defer func() {
		err = file.Close()
		if err != nil {
			log.Fatalf("close file failed, err: %v\n", err)
		}
	}()

	//定义变量result用来存储读取结果
	var result string
	//创建一个带有缓冲区的reader
	reader := bufio.NewReader(file)
	for {
		buf, err := reader.ReadBytes('\n')
		if err != nil {
			if err == io.EOF { //EOF代表文件的末尾
			//注意:为什么要判断err是否等于io.EOF?
			//因为存在这种情况,文件有内容的最后那一行尾部没有换行
			//当使用ReadBytes或者ReadString方法按照'\n'换行读取时,读到尾部没有换行的这种情况时就会报io.EOF错误
			//此时buf是读取到了内容的,如果忽略掉了,那么最终的读取结果会少了最后一行的内容
				result += string(buf)
				break
			} else {
				log.Fatalf("ReadBytes failed, err: %v\n", err)
			}
		}
		result += string(buf)
	}
	fmt.Println(result)
}

2.ReadString方法

package main

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

func main() {

    //打开文件
    file, err := os.Open("./files/test.txt")
    if err != nil {
        fmt.Println("文件打开失败,原因是:", err)
        return
    }

    //当函数退出时,要及时的关闭file
    defer func() {
        //文件及时关闭
        err = file.Close()
        if err != nil {
            fmt.Println("文件关闭失败,原因是", err)
        }
    }()

    //创建一个 *Reader,是带缓冲的
    reader := bufio.NewReader(file)
    var result string
    //循环读取文件内容
    for {
        str, err := reader.ReadString('\n') //读到一个换行就结束
        result += str
        if err == io.EOF {//io.EOF代表文件的末尾
            //注意:如果文件最后一行文字没有换行,则会一直读取到文件末尾,
            //所以即使是判断读到了文件末尾,也要把读取的内容输出一下
            break
        }
    }
    fmt.Println(result)
}

示例5: 创建文件并写入内容

第二个参数:文件代开模式(可以组合);第三个参数:权限控制(如0755)

package main

import (
	"fmt"
	"os"
)

func main() {

	//1.创建文件file.txt
	file, err := os.OpenFile("src/file.txt", os.O_WRONLY | os.O_CREATE, 0755)
	if err != nil {
		fmt.Println("文件打开/创建失败,原因是:", err)
		return
	}

	defer func() {
		err  = file.Close()
		if err != nil {
			fmt.Println("文件关闭失败,原因是:", err)
		}
	}()

	//写入数据
	var str = "暗黑西游狮驼岭,斗战胜佛孙悟空。\n"

	for i := 0; i < 5; i++ {
		file.WriteString(str)
	}
}

示例6: 写文件的四种方式

1.使用WriteAt()搭配Seek()方法实现写文件功能

package main

import (
	"io"
	"log"
	"os"
)

func main() {

	file, err := os.OpenFile("./test.txt", os.O_RDWR|os.O_CREATE, 0755)
	if err != nil {
		log.Fatalf("open file failed, err: %v\n", err)
	}
	defer func() {
		err = file.Close()
		if err != nil {
			log.Fatalf("close file failed, err: %v\n", err)
		}
	}()
    //Seek(): 修改文件的读写指针位置.
    //参数1: 偏移量. 正:向文件尾部偏移, 负:向文件头部偏移
    //参数2: 偏移起始位置
    //       io.SeekStart: 文件起始位置
    //       io.SeekCurrent: 文件当前位置
    //       io.SeekEnd: 文件结尾位置
    //返回值:表示从文件起始位置,到当前文件读写指针位置的偏移量。
    //WriteAt(): 在文件指定偏移位置,写入[]byte,通常搭配Seek()
    //参数1: 待写入的数据
    //参数2: 偏移量
    //返回: 实际写出的字节数
	for i := 0; i < 5; i++ {
		offset, _ := file.Seek(-3, io.SeekEnd)
		_, _ = file.WriteAt([]byte("你好"), offset)
	}
}

注意: 由于使用的OpenFile函数打开的文件,所以在选择打开模式的时候不能选择os.O_APPEND模式,因为该模式表示的是在文件末尾追加,这与WriteAt在指定的位置写是想冲突的,虽然我在测试的时候加上os.O_APPEND模式并没有报错,但是代码执行完之后发现,想要写入的内容并没有真正的写入到文件中。
写入前

写入后

2.一次性写文件

package main

import (
	"io/ioutil"
	"log"
)

func main() {
	str := "hello树先生"
	//如果文件已存在,则会清空原来的内容,写入新内容,如果文件不存在,则会创建文件并写入内容
	err := ioutil.WriteFile("./test.txt", []byte(str), 0755)
	if err != nil {
		log.Fatalf("写入文件错误,错误为:%v\n", err)
	}
}

3.使用带缓冲的方式写文件

package main

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

func main() {

	//1.创建文件file.txt
	file, err := os.OpenFile("src/file.txt", os.O_WRONLY | os.O_CREATE | os.O_TRUNC, 0755)
	defer func() {
		err  = file.Close()
		if err != nil {
			fmt.Println("文件关闭失败,原因是:", err)
		}
	}()

	if err != nil {
		fmt.Println("文件创建失败,原因是:", err)
		return
	}

	//写入数据
	var str = "你好,世界\n"

	//写入时,使用带缓存的*Writer
	writer := bufio.NewWriter(file)

	for i := 0; i < 5; i++ {
		writer.WriteString(str)
	}

	//因为writer是带缓存的,因此在调用writeString方法时,其实内容是先写入到缓存
	//因此需要调用Flush方法,将缓存数据写入到文件中,否则文件中会丢失数据
	writer.Flush()
}

示例7: 把一个文件内容写入到另一个文件

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {

    //打开文件,文件路径相对于GOPATH开始,或者写全路径(/Users/xxx/Go/src/file.txt)
    data, err := ioutil.ReadFile("src/1.txt")
    if err != nil {
        fmt.Println("文件打开失败,原因是:", err)
    }

    err = ioutil.WriteFile("src/2.txt", data, 0755)

    if err != nil {
        fmt.Println("文件写入失败,原因是:", err)
    }
}

示例8:使用bufio获取用户输入

package main

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

func main() {
    var s string
    var reader = bufio.NewReader(os.Stdin)
    s, _ = reader.ReadString('\n')
    fmt.Printf("读取到的内容为:%s\n", s)
}

示例9: 判断文件或目录是否存在

Go判断文件或文件夹是否存在的方法为使用os.Stat()函数返回的错误值进行判断:
(1)如果返回的错误为nil,说明文件或文件夹存在
(2)如果返回的类型使用os.IsNotExist()判断为true,说明文件或文件夹不存在
(3)如果返回的错误为其它类型,则不确定是否存在

package main

import (
	"fmt"
	"os"
)

func main() {

	isExist, err := isFileExists("src/sfile.txt")
	if err != nil {
		fmt.Println("发生错误:", err)
	}

	if isExist {
		fmt.Println("存在")
	} else {
		fmt.Println("不存在")
	}
}

//判断文件或者目录是否存在
func isFileExists(path string) (bool, error) {

	_, err := os.Stat(path)
	if err == nil {
		return true, nil
	}
	if os.IsNotExist(err) {
		return false, nil
	}
	return false, err
}

示例10: 拷贝文件、图片音视频

io.Copy方法

package main

import (
	"fmt"
	"io"
	"os"
)
func CopyFile(srcFileName string, dstFileName string) (int64, error) {

	//源文件处理
	srcFile, err := os.Open(srcFileName)
	defer func() {
		err = srcFile.Close()
		if err != nil {
			fmt.Println("源文件关闭失败,原因是:", err)
		}
	}()

	if err != nil {
		fmt.Println("源文件打开失败,原因是:", err)
		return 0, err
	}

	//目标文件处理
	dstFile, err := os.OpenFile(dstFileName, os.O_CREATE | os.O_WRONLY, 0755)
	defer func() {
		err = dstFile.Close()
		if err != nil {
			fmt.Println("目标文件关闭失败,原因是:", err)
		}
	}()
	if err != nil {
		fmt.Println("目标文件打开失败,原因是:", err)
		return 0, err
	}

	return io.Copy(dstFile, srcFile)
}

func main() {

	result, err := CopyFile("src/dst.jpeg", "src/哈哈.jpeg")

	if err == nil {
		fmt.Println("拷贝成功!拷贝的字节数为: ", result)
	}
}

对于大文件,我们还可以采用下面的方式

package main

import (
	"io"
	"log"
	"os"
)

func CopyFile(srcFileName string, dstFileName string) {
	//打开源文件
	srcFile, err := os.Open(srcFileName)
	if err != nil {
		log.Fatalf("源文件读取失败,原因是:%v\n", err)
	}
	defer func() {
		err = srcFile.Close()
		if err != nil {
			log.Fatalf("源文件关闭失败,原因是:%v\n", err)
		}
	}()

	//创建目标文件,稍后会向这个目标文件写入拷贝内容
	distFile, err := os.Create(dstFileName)
	if err != nil {
		log.Fatalf("目标文件创建失败,原因是:%v\n", err)
	}
	defer func() {
		err = distFile.Close()
		if err != nil {
			log.Fatalf("目标文件关闭失败,原因是:%v\n", err)
		}
	}()
	//定义指定长度的字节切片,每次最多读取指定长度
	var tmp = make([]byte, 1024*4)
	//循环读取并写入
	for {
		n, err := srcFile.Read(tmp)
		n, _ = distFile.Write(tmp[:n])
		if err != nil {
			if err == io.EOF {//读到了文件末尾,并且写入完毕,任务完成返回(关闭文件的操作由defer来完成)
				return
			} else {
				log.Fatalf("拷贝过程中发生错误,错误原因为:%v\n", err)
			}
		}
	}
}

func main() {
	CopyFile("./worm.mp4", "./dist.mp4")
}

示例11: 遍历目录

遍历目录

package main

//我们读写的文件一般存放于目录中.因此,有时需要指定到某一个目录下,根据目录存储的状况
//再进行文件的特定操作.接下来我们看看目录的基本操作方法.
import (
	"fmt"
	"log"
	"os"
)
//打开目录
//打开目录我们也使用OpenFile函数,但要指定不同的参数来通知系统,要打开的是一个目录文件.
//func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
//参数1: name,表示要打开的目录名称.使用绝对路径较多
//参数2: flag,表示打开文件的读写模式
//参数3: perm,表示打开权限.但对于目录来说有所不同,通常传os.ModeDir.
//返回值:由于是操作目录,所以file是指向目录的文件指针.err中保存错误信息

//读目录内容
//这与读文件有所不同.目录中存放的是文件名和子目录名.所以使用Readdir函数
//func (f *File) Readdir(n int) (fi []FileInfo, err error)
//如果n>0,Readdir函数会返回一个最多n个成员的切片。这时,如果Readdir返回一个空切片,
//它会返回一个非nil的错误说明原因。如果到达了目录f的结尾,返回值err会是io.EOF。
//
//如果n<=0,Readdir函数返回目录中剩余所有文件对象的FileInfo构成的切片。
//此时,如果Readdir调用成功(读取所有内容直到结尾),它会返回该切片和nil的错误值。
//如果在到达结尾前遇到错误,会返回之前成功读取的FileInfo构成的切片和该错误。

func main() {
	//不推荐,因为通过查看ioutil.ReadDir()函数可知,官方使用的是os.Open()函数打开的目录
	//file, err := os.OpenFile("./dir", os.O_RDWR, os.ModeDir)
	file, err := os.Open("./dir")
	if err != nil {
		log.Fatalf("文件打开失败,原因是:%v\n", err)
	}
	defer func() {
		err = file.Close()
		if err != nil {
			log.Fatalf("文件关闭失败,原因是:%v\n", err)
		}
	}()
	//Readdir方法返回一个FileInfo接口类型的切片和一个error类型的错误
	infos, err := file.Readdir(-1)
	for _, info := range infos {
		fmt.Printf("%v, %v\n", info.Name(), info.IsDir())
	}
}

仅遍历目录,忽略文件

方法1:使用os包

package main

import (
    "fmt"
    "os"
)

var dirNames = make([]string, 0, 50)
var pathSeparator = string(os.PathSeparator)
func traverseDir(filePath string) error {
    file, err := os.Open(filePath)
    if err != nil {
        return err
    }
    fileInfo, err := file.Readdir(0)
    if err != nil {
        return err
    }

    for _, value := range fileInfo {
        if value.IsDir() {
            dirNames = append(dirNames, value.Name())
            err = traverseDir(filePath+pathSeparator+value.Name())
            if err != nil {
                return err
            }
        }
    }
    return err
}

func main() {

    var filePath = "./dir"
    err := traverseDir(filePath)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(dirNames)
}

方法2:使用ioutil包

package main

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

var dirNames = make([]string, 0, 50)
var pathSeparator = string(os.PathSeparator)
func traverseDir(filePath string) error {
    fileInfos, err := ioutil.ReadDir(filePath)
    if err != nil {
        return err
    }
    for _, fileInfo :=range fileInfos {
        if fileInfo.IsDir() {
            dirNames = append(dirNames, fileInfo.Name())
            err =  traverseDir(filePath+pathSeparator+fileInfo.Name())
            if err != nil {
                return err
            }
        }
    }
    return err
}

func main() {

    var filePath = "./dir"
    err := traverseDir(filePath)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(dirNames)
}

示例12: 修改文件名

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "strings"
)

var pathSeparator = string(os.PathSeparator)
//重命名文件
func renameFileName(filePath string, old string, new string) error {
    files, err := ioutil.ReadDir(filePath)
    if err != nil {
        return err
    }
    for _, fileInfo := range files {
        if !fileInfo.IsDir() {
            err = os.Rename(filePath + pathSeparator + fileInfo.Name(),
                filePath + pathSeparator + strings.Replace(fileInfo.Name(), old, new, -1),
            )
            if err != nil {
                return err
            }
        }
    }
    return err
}

func main() {
    var filePath = "./dir"
    err := renameFileName(filePath, "f", "kkk")
    if err != nil {
        fmt.Printf("错误: %v\n", err)
    }
}

示例13:创建目录

package main

import (
	"fmt"
	"os"
)

func main() {
	//Mkdir使用指定的权限和名称创建一个目录。如果出错,会返回*PathError底层类型的错误。
	err := os.Mkdir("./foo", 0755)
	if os.IsExist(err) {
		fmt.Println("目录已存在")
		return
	}

	//MkdirAll使用指定的权限和名称创建一个目录,包括任何必要的上级目录,并返回nil,否则返回错误。
	//权限位perm会应用在每一个被本函数创建的目录上。如果path指定了一个已经存在的目录,MkdirAll不做任何操作并返回nil。
	err = os.MkdirAll("./foo/bar", 0755)
	if err != nil {
		fmt.Printf("%v\n", err)
		return
	}
}

示例14:删除文件

package main

import (
	"fmt"
	"os"
)

func main() {
	//Remove删除name指定的文件或目录。如果出错,会返回*PathError底层类型的错误。
	//该方法不能删除非空目录,如果想删除目录以及目录下的所有文件,可以使用RemoveAll
	err := os.Remove("./def")
	if os.IsNotExist(err) {
		fmt.Println("您要删除的文件或目录不存在")
		return
	}
	if err != nil {
		fmt.Println(err)
	}

	//RemoveAll删除path指定的文件,或目录及它包含的任何下级对象。
	//它会尝试删除所有东西,除非遇到错误并返回。
	//如果path指定的对象不存在,RemoveAll会返回nil而不返回错误。
	err = os.RemoveAll("./def")
	if err != nil {
		fmt.Println(err)
	}
}

文章来源: www.cnblogs.com,作者:itbsl,版权归原作者所有,如需转载,请联系作者。

原文链接:https://www.cnblogs.com/itbsl/p/13052631.html

登录后可下载附件,请登录或者注册

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件至:huaweicloud.bbs@huawei.com进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容。
评论文章 //点赞 收藏 0
点赞
分享文章到微博
分享文章到朋友圈

上一篇:DirectX11 With Windows SDK--31 阴影映射

下一篇:10_隐马尔可夫模型

评论 (0)


登录后可评论,请 登录注册

评论