golang 复制文件
本文是Mihalis Tsoukalos的“围棋”系列的一部分。 阅读第1部分： 在Go中创建随机的安全密码 ，第2部分： 在Go中构建并发TCP服务器 。
本文将向您展示如何使用Go编程语言复制文件。 尽管在Go中复制文件的方法不止三种，但是本文将介绍三种最常见的方法：使用Go库中的io.Copy()函数调用； 一次读取所有输入文件并将其写入另一个文件； 并使用缓冲区将文件分小块复制。
方法1：使用io.Copy（）
该实用程序的第一个版本将使用标准Go库的io.Copy()函数。 该实用程序的逻辑可以在copy()函数的实现中找到，如下所示：
func
copy
( src
, dst
string
)
(
int64
, error
)
{
sourceFileStat
, err
:= os
. Stat
( src
)
if err
!=
nil
{
return
0
, err
}
if
! sourceFileStat
. Mode
()
. IsRegular
()
{
return
0
, fmt
. Errorf
(
"%s is not a regular file"
, src
)
}
source
, err
:= os
. Open
( src
)
if err
!=
nil
{
return
0
, err
}
defer source
. Close
()
destination
, err
:= os
. Create
( dst
)
if err
!=
nil
{
return
0
, err
}
defer destination
. Close
()
nBytes
, err
:= io
. Copy
( destination
, source
)
return nBytes
, err
}除了测试将要复制的文件是否存在（ os.Stat(src) ）和常规文件（ sourceFileStat.Mode().IsRegular() ）以使您可以打开文件进行读取之外，所有工作都由io.Copy(destination, source)语句。 io.Copy()函数返回复制的字节数以及在复制过程中发生的第一条错误消息。 在Go中，如果没有错误消息，则错误变量的值为nil 。
您可以在io软件包文档页面上了解有关io.Copy()函数的更多信息。
执行cp1.go将生成下一种输出：
$
go run cp1
.
go
Please provide two command line arguments
!
$
go run cp1
.
go fileCP
. txt
/ tmp
/ fileCPCOPY
Copied
3826 bytes
!
$ diff fileCP
. txt
/ tmp
/ fileCPCOPY该技术尽可能简单，但给开发人员没有灵活性，这并不总是一件坏事。 但是，有时开发人员需要或想要决定他们如何读取文件。
方法2：使用ioutil.WriteFile（）和ioutil.ReadFile（）
ioutil.ReadFile()和ioutil.WriteFile()函数。
第一个函数将整个文件的内容读取到一个字节片中，第二个函数将一个字节片的内容写入一个文件中。
该实用程序的逻辑可以在以下Go代码中找到：
input
, err
:= ioutil
. ReadFile
( sourceFile
)
if err
!=
nil
{
fmt
. Println
( err
)
return
}
err
= ioutil
. WriteFile
( destinationFile
, input
,
0644
)
if err
!=
nil
{
fmt
. Println
(
"Error creating"
, destinationFile
)
fmt
. Println
( err
)
return
}除了两个if块（它们是Go的工作方式之一）之外，您还可以看到该程序的功能可以在ioutil.ReadFile()和ioutil.WriteFile()语句中找到。
执行cp2.go将生成下一种输出：
$
go run cp2
.
go
Please provide two command line arguments
!
$
go run cp2
.
go fileCP
. txt
/ tmp
/ copyFileCP
$ diff fileCP
. txt
/ tmp
/ copyFileCP请注意，尽管此技术将复制文件，但是当您要复制大文件时，它可能效率不高，因为ioutil.ReadFile()返回的字节片也将非常大。
方法3：使用os.Read（）和os.Write（）
在Go中复制文件的第三种方法是使用cp3.go实用程序，该实用程序将在本节中开发。 它接受三个参数：输入文件的文件名，输出文件的文件名和缓冲区的大小。
cp3.go的最重要部分位于以下for循环中，可以在copy() function:找到该循环copy() function:
buf
:=
make
([]
byte
, BUFFERSIZE
)
for
{
n
, err
:= source
. Read
( buf
)
if err
!=
nil && err
!= io
. EOF
{
return err
}
if n
==
0
{
break
}
if _
, err
:= destination
. Write
( buf
[: n
]); err
!=
nil
{
return err
}
}该技术使用os.Read()将输入文件的一小部分读取到名为buf并将os.Write()用于将该缓冲区的内容写入文件中。 当读取错误或到达文件末尾（ io.EOF ）时，复制过程停止。
执行cp3.go将生成下一种输出：
$
go run cp3
.
go
usage
: cp3 source destination BUFFERSIZE
$
go run cp3
.
go fileCP
. txt
/ tmp
/ buf10
10
Copying fileCP
. txt to
/ tmp
/ buf10
$
go run cp3
.
go fileCP
. txt
/ tmp
/ buf20
20
Copying fileCP
. txt to
/ tmp
/ buf20如您所见，缓冲区的大小极大地影响了cp3.go的性能。
做一些基准测试
本文的最后一部分将尝试使用time(1)命令行实用程序比较这三个程序以及cp3.go在各种缓冲区大小下的性能。
以下输出显示了复制500MB文件时cp1.go ， cp2.go和cp3.go的性能：
$ ls
- l INPUT
- rw
- r
-- r
--
1 mtsouk staff
512000000 Jun
5 09
:
39 INPUT
$ time
go run cp1
.
go INPUT
/ tmp
/ cp1
Copied
512000000 bytes
!
real 0m0
. 980s
user 0m0
. 219s
sys 0m0
. 719s
$ time
go run cp2
.
go INPUT
/ tmp
/ cp2
real 0m1
. 139s
user 0m0
. 196s
sys 0m0
. 654s
$ time
go run cp3
.
go INPUT
/ tmp
/ cp3
1000000
Copying INPUT to
/ tmp
/ cp3
real 0m1
. 025s
user 0m0
. 195s
sys 0m0
. 486s输出结果表明，所有三个实用程序的性能都非常相似，这意味着标准Go库的功能非常聪明且经过优化。
现在，让我们测试缓冲区大小如何影响cp3.go的性能。 在缓冲区速度为10、20和1,000字节的情况下执行cp3.go在相当快的计算机上复制500MB文件将产生以下结果：
$ ls
- l INPUT
- rw
- r
-- r
--
1 mtsouk staff
512000000 Jun
5 09
:
39 INPUT
$ time
go run cp3
.
go INPUT
/ tmp
/ buf10
10
Copying INPUT to
/ tmp
/ buf10
real 6m39
. 721s
user 1m18
. 457s
sys 5m19
. 186s
$ time
go run cp3
.
go INPUT
/ tmp
/ buf20
20
Copying INPUT to
/ tmp
/ buf20
real 3m20
. 819s
user 0m39
. 444s
sys 2m40
. 380s
$ time
go run cp3
.
go INPUT
/ tmp
/ buf1000
1000
Copying INPUT to
/ tmp
/ buf1000
real 0m4
. 916s
user 0m1
. 001s
sys 0m3
. 986s生成的输出表明，缓冲区越大， cp3.go实用程序的性能cp3.go ，这或多或少是可以预期的。 而且，使用小于20字节的缓冲区大小来复制大文件是一个非常缓慢的过程，应避免使用。
您可以在GitHub上找到cp1.go ， cp2.go和cp3.go的Go代码。
如果您有任何疑问或反馈，请在下面发表评论或在Twitter上与我联系。
翻译自: https://opensource.com/article/18/6/copying-files-go
golang 复制文件
