开发者

关于Go语言中的IO操作详解

目录
  • 一、os包简介
  • 二、常用函数与示例
    • 1. 文件操作
      • 1.1 获取文件信息
      • 1.2 创建文件
      • 1.3 删除文件
      • 1.4 重命名或移动文件
      • 1.5 打开文件
      • 1.6 读取文件
      • 1.7 IO写
    • 2. 目录操作
      • 2.1 创建目录
      • 2.2 更改当前工作目录
    • 3. 环境变量
      • 3.1 获取环境变量
    • 4. 程序退出
      • 5. 获取系统信息
        • 6. 执行外部命令
          • 1. 执行简单命令
          • 2. 获取命令输出
          • 3. 处理标准输出和标准错误
      • 三、文件复制
        • 1. 自定义的文件复制实现
          • 2. 使用系统自带的io.Copy()方法复制
            • 3. 使用os.ReadFile和os.WriteFile来实现读取写入,从而实现复制
              • 4. io.CopyBuffer() 适合大文件复制

              在现代软件开发中,高效的输入输出(I/O)操作是提高程序性能的关键之一。Go语言提供了丰富的I/O操作接口,使得文件读写、网络通信等任务变得简单而高效。

              Go语言的I/O操作主要通过标准库中的io包和os包实现。o包提供了一系列用于输入和输出操作的基本接口和原语。这些接口和原语构成了Go语言中处理I/O操作的基础,支持多种I/O设备的读写操作,包括文件、网络连接、内存缓冲区等。而os包则提供了对操作系统功能的封装,包括文件操作、进程管理等。

              一、os包简介

              os包是Go语言标准库中的一个重要包,提供了操作系统相关的功能接口。通过os包,我们可以执行各种底层操作,如读取和写入文件、获取系统信息、执行外部命令等。

              二、常用函数与示例

              1. 文件操作

              1.1 获取文件信息

              Stat:获取文件信息对象,符号链接会跳转。

              Lstat:获取文件信息对象,符号链接不跳转。

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              //看下fileinfo接口
              // file
              // fileInfo
              /*
              type FileInfo interface {
                 Name() string       // base name of the file
                 Size() int64        // length in bytes for regular files; system-dependent for others
                 Mode() FileMode     // file mode bits : 权限
                 ModTime() time.Time // modification time
                 IsDir() bool        // abbreviation for Mode().IsDir()
              
                 // 获取更加详细的文件信息, *syscall.Stat_t  反射来获取
                 Sys() any           // underlying data source (can return nil)
              */
              
              func main() {
                  // 获取某个文件的状态
                  //func Stat(name string) (FileInfo, error)
                  fileinfo, err := os.Stat("F:\\goworks\\src\\jingtian\\yufa\\type别名\\type别名.go")
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  fmt.Println(fileinfo.Name())    // 文件名 demo01.go
                  fmt.Println(fileinfo.IsDir())   // 是否目录 false
                  fmt.Println(fileinfo.ModTime()) // 文件的修改时间 2024-09-26 10:03:01.0946679 +0800 CST
                  fmt.Println(fileinfo.Size())    // 文件大小 1542 字节数 
                  fmt.Println(fileinfo.Mode())    // 权限 -rw-rw-rw-
              }
              

              关于Go语言中的IO操作详解

              1.2 创建文件

              Create:创建文件,如果文件存在,则清空原文件。

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              func main() {
                  //创建文件,文件不存在就创建文件,如果文件存在,则清空原文件。
                      // func Create(name string) (*File, error)
              
                  file, err := os.Create("example.txt")
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  //关闭文件,延迟执行
                  defer file.Close()
              
                  //向文件中写内容
                  // func (f *File) WriteString(s string) (n int, err error)
                  _, err = file.WriteString("Hello, World!")
                  if err != nil {
                      fmt.Println(err)
                  }
                  fmt.Println("File created successfully")
              }
              

              文件创建,并且写入成功

              关于Go语言中的IO操作详解

              创建的文件默认权限是0666

              关于Go语言中的IO操作详解

              1.3 删除文件

              Remove:删除文件或目录(单一文件)只能删除空文件夹,文件不存在会报错。如果文件夹中有文件也删不掉

              RemoveAll:递归删除文件或目录,文件或目录不存在不报错,返回nil。

              关于Go语言中的IO操作详解

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              func main() {
                  // 删除文件
                  // func Remove(name string) error
                  //文件不存在会报错
                  err := os.Remove("example.txt")
                  if err != nil {
                      fmt.Println(err)
                  } else {
                      fmt.Println("File removed successfully")
                  }
              
                  // 递归删除目录
                  // func RemoveAll(path string) error
                  //目录不存在返回nil 不会报错
                  //可以删除指定目录下的目录或文件
                  err = os.RemoveAll("testdir\\mydir.go")
                  if err != nil {
                      fmt.Println(err)
                  } else {
                      fmt.Println("Directory removed successfully")
                  }
              }
              

              关于Go语言中的IO操作详解

              1.4 重命名或移动文件

              Rename:重命名文件或移动文件。

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              func main() {
                  // 重命名文件
                  // func Rename(oldpath, newpath string) error
                  err := os.Rename("张三.txt", "新张三.txt")
                  if err != nil {
                      fmt.Println(err)
                  } else {
                      fmt.Println("File renamed successfully")
                  }
              
                  // 移动文件
                  err = os.Rename("新张三.txt", "testdir\\新张三.txt")
                  if err != nil {
                      fmt.Println(err)
                  } else {
                      fmt.Println("File moved successfully")
                  }
              }
              

              1.5 打开文件

              使用os.Open函数可以打开一个文件,返回一个*os.File类型的文件对象。如果文件打开失败,会返回一个错误。

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              funjavascriptc main() {
                  //func Open(name string) (*File, error)
                  file, err := os.Open("example.txt")
                  if err != nil {
                      fmt.Println("Error opening file:", err)
                      return
                  }
                  defer file.Close()
                  fmt.Println("File opened successfully")
                  //打印打开的文件,是个内存地址
                  fmt.Println("Reading file:", file)
              }
              

              关于Go语言中的IO操作详解

              打开文件常用方式二:os.OpenFile

              在Go语言中,文件的读写操作是使用非常频繁的功能之一。os.OpenFile函数是Go标准库中用于打开文件的强大工具,它允许以多种模式打开文件,并可以设置文件的权限。

              os.OpenFile函数简介

              os.OpenFile函数用法如下:

              func OpenFile(name string, flag int, perm FileMode) (File, error)

              name:要打开的文件名或路径。

              flag:打开文件的模式,可以是多个标志的按位或组合。常见的标志包括:

              os.O_RDONLY:只读模式。

              os.O_WRONLY:只写模式。

              os.O_RdwR:读写模式。

              os.O_APPEND:追加模式,在文件末尾写入数据而不覆盖原有数据。只要有这个参数,就会采用追加模式

              os.O_CREATE:如果文件不存在则创建文件。

              os.O_EXCL:与O_CREATE一起使用,可执行权限。

              os.O_SYNC:同步模式,将文件更改刷新到磁盘。

              os.O_TRUNC:截断模式,清空文件内容。

              perm:文件权限,表示文件的读写权限,默认为0666(即所有用户都可读写)。

              返回值是一个指向打开文件的File对象和一个可能出现的错误。如果文件打开成功,则可以通过该文件对象进行读取和写入操作。

              使用os.OpenFile写文件

              以下是一个使用os.OpenFile函数写文件的示例:

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              func main() {
                  // 以追加、创建、读写模式打开文件
                  file, err := os.OpenFile("./example.txt", os.O_APPEND|os.O_CREATE|os.O_RDWR, 0666)
                  if err != nil {
                      fmt.Println("打开文件失败:", err)
                      return
                  }
                  defer file.Close() // 确保在函数执行完毕后关闭文件
              
                  // 写入文件
                  _, err = file.Write([]byte("Hello, Go!\n"))
                  if err != nil {
                      fmt.Println("写入文件失败:", err)
                      return
                  }
              
                  fmt.Println("文件写入成功")
              }
              

              将内容追加到文件中

              关于Go语言中的IO操作详解

              1.6 读取文件

              使用os.File对象的Read方法可以从文件中读取数据。Read方法会将数据读取到一个字节切片中,并返回读取的字节数和可能发生的错误。

              需要借助 file.Read([]byte)读取 ,将file中的数据读取到 []byte 中, n,err n读取到的行数,err 错误,EOF错误,就代表文件读取完毕了

              一直调用read,就代表光标往后移动…

              以下是一个使用os.Open函数读文件的示例:

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              // 读取文件数据
              func main() {
                  // 我们习惯于在建立连接时候通过defer来关闭连接,保证程序不会出任何问题,或者忘记关闭
                  // 建立连接
                  file, _ := os.Open("example.txt")
                  // 关闭连接
                  defer file.Close()
              
                  // 读代码 ,Go 的错误机制,让我们专心可以写业务代码。
              
                  // 1、创建一个容器 (二进制文本文件--0100101010 => 读取流到一个容器 => 读取容器的数据)
                  //一次性读取的内容长度为切片的长度,切片长度为2,容量为1024
                  bs := make([]byte, 2, 1024) // 缓冲区,可以接受我们读取的数据 这里设置的是一次性读取两个字节
                  fmt.Printf("字节切片数据类型%T\n", bs)
                  // 2、读取到缓冲区中。 // 汉字一个汉字占 3个字节
                  // func (f *File) Read(b []byte) (n int, err error) 返回读到的字节数和错误
                  // At end of file, Read returns 0, io.EOF. php读到文件末尾返回0和io.EOF
                  n, err := file.Read(bs)
                  fmt.Println(n)
                  fmt.Println(err)
                  //每次读取光标移动切片的长度,将读取的内容存到切片中。如果读取的文件是文本数据,可以通过string方法将切片中的内容转换为字符串
                  //如果是MP4呀,音乐,图片等文件,就不要用string转换了
                  fmt.Println(string(bs)) // 读取到的字符串  ab
              
                  //继续往下读
                  // 光标不停的向下去指向,读取出来的内容就存到我们的容器中。
                  file.Read(bs)
                  fmt.Println(string(bs)) // 读取到的字符串  cd
              
                  file.Read(bs)
                  fmt.Println(string(bs)) // 读取到的字符串  e
              
                  //读到文件末尾,得到的n是0,err是EOF
                  n, err = file.Read(bs)
                  fmt.Println(n)
                  fmt.Println(err) // EOF ,读取到了文件末尾。err就会返回EOF。
                  //最后读到了e,将原来切片中的cd的c覆盖了,得到的最终结果是ed
                  fmt.Println(string(bs)) // 读取到的字符串
              
              }
              

              关于Go语言中的IO操作详解

              1.7 IO写

              写的话,要考虑文件的权限问题,大致流程如下

              建立连接 (设置权限:可读可写,扩充这个文件的append) os.OpenFile

              关闭连接

              写入文件常用的方法

              • file.Write
              • file.WriteString

              先看下example.txt文件

              关于Go语言中的IO操作详解

              package main
              
              import (
                  "http://www.devze.comfmt"
                  "os"
              )
              
              func main() {
              
                  fileName := "example.txt"
                  // 权限:如果我们要向一个文件中追加内容, O_APPEND, 如果没有,就是从头开始写
                  file, _ := os.OpenFile(fileName, os.O_WRONLY|os.O_RDONLY|os.O_APPEND, os.ModePerm)
                  defer file.Close()
              
                  // 操作 字节切片写入
                  bs := []byte{65, 66, 67, 68, 69} // A B C D E  ASCII编码
                  // func (f *File) Write(b []byte) (n int, err error)
                  //write方法 写入的是二进制数据字节流,即字节切片
                  n, err := file.Write(bs)
                  if err != nil {
                      fmt.Println(err)
                  }
                  fmt.Println(n)
              
                  // string类型的写入,可以直接将字符串写入到文件中
                  n, err = file.WriteString("hhahahahah哈哈哈哈哈哈哈")
                  if err != nil {
                      fmt.Println(err)
                  }
                  fmt.Println(n)
              }
              

              关于Go语言中的IO操作详解

              再看下example.txt文件,可以看到我们写入的内容全部追加到文件末尾

              关于Go语言中的IO操作详解

              如果打开文件的方式不包含os.O_APPEND 则是将源文件覆盖写。os.O_APPEND的意思是,在打开文件时,将光标移动到文件末尾

              2. 目录操作

              2.1 创建目录

              Mkdir:使用指定的权限和名称创建一个目录,目录存在会报错。

              MkdirAll:递归创建目录,包括任何必要的上级目录,目录存在不报错。

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              func main() {
                  // 创建单个目录
                  // func Mkdir(name string, perm FileMode) error
                  // os.ModePerm 是0777的权限
                  //mkidr创建目录,目录存在的情况下,会报错 Cannot create a file when that file already exists.
                  err := os.Mkdir("singledir", os.ModePerm)
                  if err != nil {
                      fmt.Println(err)
                  } else {
                      fmt.Println("Single directory created successfully")
                  }
              
                  // 递归创建目录,目录存在不报错
                  // func MkdirAll(path string, perm FileMode) error
                  err = os.MkdirAll("nested/dirs/test", os.ModePerm)
                  if err != nil {
                      fmt.Println(err)
                  } else {
                      fmt.Println("Nested directories created successfully")
                  }
              }
              

              2.2 更改当前工作目录

              Getwd:获取当前工作目录。

              Chdir:修改当前工作目录。

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              func main() {
                  // 获取当前工作目录
                  path, err := os.Getwd()
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  fmt.Println("Current working directory:", path)
              
                  // 修改当前工作目录
                  err = os.Chdir("../")
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  path, err = os.Getwd()
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  fmt.Println("New working directory:", path)
              }
              

              关于Go语言中的IO操作详解

              3. 环境变量

              3.1 获取环境变量

              Environ:返回所有的环境变量,格式为“key=value”的字符串切片。

              Getenv:检索并返回名为key的环境变量的值,如果不存在则返回空字符串。

              Setenv:

              函数定义:func Setenv(key, value string) error

              功能:设置名为key的环境变量,如果出错会返回该错误。

              package main
              
              import (
                  "fmt"
                  "os"
                  "strings"
              )
              
              func main() {
                  // 设置环境变量
                  err := os.Setenv("MY_ENV_VAR", "my_value")
                  if err != nil {
                      fmt.Println(err)
                  } else {
                      fmt.Println("Environment variable set successfully")
                  }
              
                  // 获取并打印刚设置的环境变量
                  value := os.Getenv("MY_ENV_VAR")
                  fmt.Println("MY_ENV_VAR:", value)
              
                  //查看所有环境变量
                  envs := os.Environ()
                  for _, env := range envs {
                      cache := strings.Split(env, "=")
                      fmt.Printf("key=%v value=%v\n", cache[0], cache[1])
              
                  }
              
                  // 清除所有环境变量(谨慎使用)
                  // err = os.Clearenv()
                  // if err != nil {
                  //     fmt.Println(err)
                  // } else {
                  //     fmt.Println("All environment variables cleared")
                  // }
              }
              

              关于Go语言中的IO操作详解

              4. 程序退出

              Exit:让当前程序以给出的状态码code退出。一般来说,状态码0表示成功,非0表示出错。程序会立刻终止,并且defer的函数不会被执行。

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              func main() {
                  // 正常退出
                  fmt.Println("Exiting the program successfully")
                  //os.Exit(0)
              
                  // 异常退出(不会执行到这里的代码)
                  fmt.Println("This line will not be executed")
                  os.Exit(1)
              }
              

              关于Go语言中的IO操作详解

              5. 获取系统信息

              Hostname:返回内核提供的主机名。

              Getuid:返回调用者的用户ID。

              Getgid:返回调用者的组ID。

              Getpid:返回调用者所在进程的进程ID。

              package main
              
              import (
                  "fmt"
                  "os"
              )
              
              func main() {
                  // 获取主机名
                  hostname, err := os.Hostname()
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  fmt.Println("Hostname:", hostname)
              
                  // 获取用户ID
                  uid := os.Getuid()
                  fmt.Println("User ID:", uid)
              
                  // 获取组ID
                  gid := os.Getgid()
                  fmt.Println("Group ID:", gid)
              
                  // 获取进程ID
                  pid := os.Getpid()
                  fmt.Println("Process ID:", pid)
              }
              

              关于Go语言中的IO操作详解

              6. 执行外部命令

              os/exec包用于执行外部命令,它提供了更高级别的接口来创建和管理进程。

              1. 执行简单命令

              package main
              
              import (
                  "fmt"
                  "os/exec"
              )
              
              func main() {
              
                  //查看系统中是否安装有该命令
                  cmd_path, err := exec.LookPath("ipconfig")
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  fmt.Println("系统中有该命令,命令路径为:", cmd_path)
                  //Command每个参数都不能包含空格。多个参数,用引号包裹,逗号隔开
                  cmd := exec.Command("ipconfig")
                      // 如果不需要命令的输出,直接调用cmd.Run()即可
              
                  err2 := cmd.Run()
                  if err2 != nil {
                      fmt.Println("Error:", err2)
                  } else {
                      fmt.Println("Command executed successfully")
                  }
              }
              

              关于Go语言中的IO操作详解

              使用exec.Command函数创建一个代表外部命令的Cmd对象,然后使用Run方法执行命令并等待其完成。

              我们使用 exec.Command() 创建了一个执行 ipconfig 命令的 *exec.Cmd,然后使用 Run() 方法启动了命令。

              请注意,使用 exec.Command() 创建的命令默认不会有任何输出。如果我们想获取命令的标准输出,我们可以使用 Output() 或 CombinedOutput() 方法。如果我们想获取命令的标准错误输出,我们需要单独设置 Cmd.Stderr 字段。

              2. 获取命令输出

              使用Output方法运行命令并返回其标准输出的内容。

              package main
              
              import (
                  "fmt"
                  "os/exec"
              )
              
              func main() {
                  //查看系统中是否安装有该命令
                  cmd_path, err := exec.LookPath("ipconfig")
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  fmt.Println("系统中有该命令,命令路径为:", cmd_path)
                  cmd := exec.Command("ipconfig")
                  output, err := cmd.Output()
                  if err != nil {
                      fmt.Println("Error:", err)
                  } else {
                      fmt.Println("Command output:", string(output))
                  }
              }
              

              3. 处理标准输出和标准错误

              CombinedOutput

              func (c *Cmd) CombinedOutput() ([]byte, error)

              说明:运行命令并返回组合到一起的标准输出和标准错误

              package main
              
              import (
                  "fmt"
                  "os/exec"
              )
              
              func main() {
              
                  //查看系统中是否安装有该命令
                  cmd_path, err := exec.LookPath("ping")
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  fmt.Println("系统中有该命令,命令路径为:", cmd_path)
              
                  // 创建一个新的命令,例如运行dir命令
                  cmd := exec.Command("ping", "www.baidu.com")
              
                  //获取标准输出
                  out, err := cmd.CombinedOutput()
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  fmt.Println("标准输出为:", string(out))
              
              }
              

              关于Go语言中的IO操作详解

              三、文件复制

              文件复制需要考虑的问题:

              1、拿到需求,分析需求,编辑函数 copy()

              2、编写参数(源文件,目标地址,缓冲区大小)

              3、读取源文件,保存到缓冲区中

              4、读取缓冲区的内容,将内容写入到新文件中

              5、确保源文件读取完毕了,使用到for()循环。循环结束标志 io.EOF或者读取到的字节数为0

              1. 自定义的文件复制实现

              我们创建个目录utils。里面创建个copy.go

              package utils
              
              import (
                  "fmt"
                  "io"
                  "os"
              )
              
              // Copy 方法需要参数为:source 源文件 ,destination 目标文件,缓冲区大小
              func Copy(source, destination string, bufferSize int) {
              
                  // 读取文件,读文件open方法就可以
                  sourceFile, err := os.Open(source)
                  if err != nil {
                      fmt.Println("Open错误:", err)
                  }
              
                  // 输出文件 O_WRONLY , O_CREATE 如果不不存在,则会创建
                  destinationFile, err := os.OpenFile(destination, os.O_WRONLY|os.O_CREATE, os.ModePerm)
                  if err != nil {
                      fmt.Println("OpenFile错误:", err)
                  }
                  // 关闭连接
                  defer sourceFile.Close()
                  defer destinationFile.Close()
              
                  // 专注业务代码,拷贝
                  // 创建缓冲区大小
                  buf := make([]byte, bufferSize)
                  // 循环读取,写入
                  for {
                      //一次读取设置的缓冲区大小的数据
                      n, err := sourceFile.Read(buf)
                      // 循环结束标志
                      if n == 0 || err == io.EOF {
                          fmt.Println("读取完毕源文件,复制完毕")
                          break
                      } else if err != nil {
                          fmt.Println("读取错误:", err)
                          return // 错误之后,必须要return终止函数执行。
                      }
                      // 将缓冲区的东西写出到目标文件
                      // 因为循环写入过程中没有关闭文件,所以可以持续写入
                      //根据实际读取的长度写入,防止最后一次读取时,读取的少于缓冲区长度
                      _, err = destinationFile.Write(buf[:n])
                      if err != nil {
                          fmt.Println("写出错误:", err)
                      }
                  }
              
              }
              

              关于Go语言中的IO操作详解

              调用我们的copy方法,实现文件copy

              package main
              
              import "jingtian/yufa/io操作/utils"
              
              func main() {
                  source := "EXKWPoUUTIC:\\Users\\dell\\Desktop\\appsearch.zip"
                  dest := "F:\\goworks\\src\\jingtian\\yufa\\io操作\\目标文件.zip"
              
                  utils.Copy(source, dest, 1024)
              }
              

              关于Go语言中的IO操作详解

              运行,可以将源文件复制到www.devze.com目标地址

              关于Go语言中的IO操作详解

              2. 使用系统自带的io.Copy()方法复制

              // Copy2 使用系统自带的io.Copy方法
              func Copy2(source, destination string) {
                  // 读取文件
                  sourceFile, err := os.Open(source)
                  if err != nil {
                      fmt.Println("Open错误:", err)
                  }
                  // 输出文件 O_WRONLY , O_CREATE 如果不不存在,则会创建
                  destinationFile, err := os.OpenFile(destination, os.O_WRONLY|os.O_CREATE, os.ModePerm)
                  if err != nil {
                      fmt.Println("OpenFile错误:", err)
                  }
                  // 关闭
                  defer sourceFile.Close()
                  defer destinationFile.Close()
              
                  // 具体的实现
                  // 不用我们自己写循环读取写入了,直接调用系统的io.Copy()方法
                  // func Copy(dst Writer, src Reader) (written int64, err error) 返回写入的字节数和错误
                  written, err := io.Copy(destinationFile, sourceFile)
                  if err != nil {
                      fmt.Println("复制时出现错误", err)
                      return
                  }
                  fmt.Println("文件的字节大小:", written)
              }
              

              3. 使用os.ReadFile和os.WriteFile来实现读取写入,从而实现复制

              // Copy3 使用os.ReadFile和os.WriteFile来实现读取写入,从而实现复制
              func Copy3(source, destination string) {
                  // func ReadFile(name string) ([]byte, error)
                  fileBuffer, _ := os.ReadFile(source)
                  //func WriteFile(name string, data []byte, perm FileMode) error
                  err := os.WriteFile(destination, fileBuffer, 0644)
                  if err != nil {
                      fmt.Println(err)
                      return
                  }
                  fmt.Println("文件复制完成")
              
              }
              

              4. io.CopyBuffer() 适合大文件复制

              // Copy4 io.CopyBuffer() 适合大文件
              func Copy4(source, destination string, bufferSize int) {
                  // 读取文件
                  sourceFile, err := os.Open(source)
                  if err != nil {
                      fmt.Println("Open错误:", err)
                  }
                  // 输出文件 O_WRONLY , O_CREATE 如果不不存在,则会创建
                  destinationFile, err := os.OpenFile(destination, os.O_WRONLY|os.O_CREATE, os.ModePerm)
                  if err != nil {
                      fmt.Println("OpenFile错误:", err)
                  }
                  // 关闭
                  defer sourceFile.Close()
                  defer destinationFile.Close()
              
                  // 具体的实现
              
                  // 创建缓冲区大小
                  buf := make([]byte, bufferSize)
                  // 不用我们自己写循环读取写入了,直接调用系统的io.Copy()方法
                  //io.copy这个适合小文件,大文件使用io.CopyBuffer
                  // func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)
                  written, err := io.CopyBuffer(destinationFile, sourceFile, buf)
                  if err != nil {
                      fmt.Println("复制时出现错误", err)
                      return
                  }
                  fmt.Println("文件的字节大小:", written)
              }
              

              以上就是关于Go语言中的IO操作详解的详细内容,更多关于Go语言IO操作的资料请关注编程客栈(www.devze.com)其它相关文章!

              0

              上一篇:

              下一篇:

              精彩评论

              暂无评论...
              验证码 换一张
              取 消

              最新开发

              开发排行榜