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上与我联系。
golang 复制文件