1. 引言
io.Copy 函式是一個非常好用的函式，能夠非常方便得將資料進行拷貝，本文我們將從io.Copy 函式的基本定義出發，講述其基本使用和實作原理，以及一些注意事項，基于此完成對io.Copy 函式的介紹，
2. 基本說明
2.1 基本定義
Copy函式用于將資料從源（io.Reader）復制到目標（io.Writer），它會持續復制直到源中的資料全部讀取完畢或發生錯誤，并回傳復制的位元組數和可能的錯誤，函式定義如下:
func Copy(dst io.Writer, src io.Reader) (written int64, err error)
其中dst 為目標寫入器，用于接收源資料；src則是源讀取器，用于提供資料，
2.2 使用示例
下面提供一個使用 io.Copy 實作資料拷貝的代碼示例，比便更好得理解和使用Copy函式，代碼示例如下:
package main
import (
"fmt"
"io"
"os"
)
func main() {
fmt.Print("請輸入一個字串：")
src := readString()
// 通過io.Copy 函式能夠將 src 的全部資料 拷貝到 控制臺上輸出
written, err := io.Copy(os.Stdout, src)
if err != nil {
fmt.Println("復制程序中發生錯誤：", err)
return
}
fmt.Printf("\n成功復制了 %d 個位元組，\n", written)
}
func readString() io.Reader {
buffer := make([]byte, 1024)
n, _ := os.Stdin.Read(buffer)
// 如果實際讀取的位元組數少于切片長度，則截取切片
if n < len(buffer) {
buffer = buffer[:n]
}
return strings.NewReader(string(buffer))
}
在這個例子中，我們首先使用readString函式從標準輸入中讀取字串，然后使用strings.NewReader將其包裝為io.Reader回傳，
然后，我們呼叫io.Copy函式，將讀取到資料全部復制到標準輸出（os.Stdout），最后，我們列印復制的位元組數，可以運行這個程式并在終端輸入一個字串，通過Copy函式，程式最侄訓將字串列印到終端上，
3. 實作原理
在了解了io.Copy 函式的基本定義和使用后，這里我們來對 io.Copy 函式的實作來進行基本的說明，加深對 io.Copy 函式的理解，
io.Copy基本實作原理如下，首先創建一個緩沖區，用于暫存從源Reader讀取到的資料，然后進入一個回圈，每次回圈從源Reader讀取資料，然后存盤到之前創建的緩沖區，之后再寫入到目標Writer中，不斷重復這個程序，直到源Reader回傳EOF，此時代表資料已經全部讀取完成，io.Copy也完成了從源Reader往目標Writer拷貝全部資料的作業，
在這個程序中，如果往目標Writer寫入資料程序中發生錯誤，亦或者從源Reader讀取資料發生錯誤，此時io.Copy函式將會中斷，然后回傳對應的錯誤，下面我們來看io.Copy的實作:
func Copy(dst Writer, src Reader) (written int64, err error) {
// Copy 函式 呼叫了 copyBuffer 函式來實作
return copyBuffer(dst, src, nil)
}
func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
// 如果 源Reader 實作了 WriterTo 介面,直接呼叫該方法 將資料寫入到 目標Writer 當中
if wt, ok := src.(WriterTo); ok {
return wt.WriteTo(dst)
}
// 同理，如果 目標Writer 實作了 ReaderFrom 介面,直接呼叫ReadFrom方法
if rt, ok := dst.(ReaderFrom); ok {
return rt.ReadFrom(src)
}
// 如果沒有傳入緩沖區，此時默認 創建一個 緩沖區
if buf == nil {
// 默認緩沖區 大小為 32kb
size := 32 * 1024
// 如果源Reader 為LimitedReader, 此時比較 可讀資料數 和 默認緩沖區，取較小那個
if l, ok := src.(*LimitedReader); ok && int64(size) > l.N {
if l.N < 1 {
size = 1
} else {
size = int(l.N)
}
}
buf = make([]byte, size)
}
for {
// 呼叫Read方法 讀取資料
nr, er := src.Read(buf)
if nr > 0 {
// 將資料寫入到 目標Writer 當中
nw, ew := dst.Write(buf[0:nr])
// 判斷寫入是否 出現了 錯誤
if nw < 0 || nr < nw {
nw = 0
if ew == nil {
ew = errInvalidWrite
}
}
// 累加 總寫入資料
written += int64(nw)
if ew != nil {
err = ew
break
}
// 寫入位元組數 小于 讀取位元組數,此時報錯
if nr != nw {
err = ErrShortWrite
break
}
}
if er != nil {
if er != EOF {
err = er
}
break
}
}
return written, err
}
從上述基本原理和代碼實作來看，io.Copy 函式的實作還是非常簡單的，就是申請一個緩沖區，然后從源Reader讀取一些資料放到緩沖區中，然后再將緩沖區的資料寫入到 目標Writer， 如此往復，直到資料全部讀取完成，
4. 注意事項
4.1 注意關閉源Reader和目標Writer
在使用io.Copy 進行資料拷貝時，需要指定源Reader 和 目標Writer，當io.Copy 完成資料拷貝作業后，我們需要呼叫Close 方法關閉 源Reader 和 目標Writer，如果沒有適時關閉資源，可能會導致一些不可預料情況的出現，
下面展示一個使用 io.Copy 進行檔案復制的代碼示例，同時簡單說明不適時關閉資源可能導致的問題：
package main
import (
"fmt"
"io"
"os"
)
func main() {
sourceFile := "source.txt"
destinationFile := "destination.txt"
// 打開源檔案
src, err := os.Open(sourceFile)
if err != nil {
fmt.Println("無法打開源檔案:", err)
return
}
// 呼叫Close方法
defer src.Close()
// 創建目標檔案
dst, err := os.Create(destinationFile)
if err != nil {
fmt.Println("無法創建目標檔案:", err)
return
}
// 呼叫Close 方法
defer dst.Close()
// 執行檔案復制
_, err = io.Copy(dst, src)
if err != nil {
fmt.Println("復制檔案出錯:", err)
return
}
fmt.Println("檔案復制成功!")
}
使用 io.Copy 函式將源檔案的內容復制到目標檔案中，在結束代碼之前，我們需要適時地關閉源文件和目標檔案，以上面使用io.Copy 實作檔案復制功能為例，如果我們沒有適時關閉資源，首先是可能會導致檔案句柄泄漏，資料不完整等一系列問題的出現，
因此我們在io.Copy函式之后，需要在適當的地方呼叫Close關閉系統資源，
4.2 考慮性能問題
io.Copy 函式默認使用一個32KB大小的緩沖區來復制資料，如果我們處理的是大型檔案，亦或者是高性能要求的場景，此時是可以考慮直接使用io.CopyBuffer 函式，自定義緩沖區大小，以優化復制性能，而io.Copy和io.CopyBuffer 底層其實都是呼叫io.copyBuffer 函式的，二者底層實作其實沒有太大的區別，
下面通過一個基準測驗，展示不同緩沖區大小對資料拷貝性能的影響:
func BenchmarkCopyWithBufferSize(b *testing.B) {
// 本地運行時, 檔案大小為 100 M
filePath := "largefile.txt"
bufferSizes := []int{32 * 1024, 64 * 1024, 128 * 1024} // 不同的緩沖區大小
for _, bufferSize := range bufferSizes {
b.Run(fmt.Sprintf("BufferSize-%d", bufferSize), func(b *testing.B) {
for n := 0; n < b.N; n++ {
src, _ := os.Open(filePath)
dst, _ := os.Create("destination.txt")
buffer := make([]byte, bufferSize)
_, _ = io.CopyBuffer(dst, src, buffer)
_ = src.Close()
_ = dst.Close()
_ = os.Remove("destination.txt")
}
})
}
}
這里我們定義的緩沖區大小分別是32KB, 64KB和128KB，然后使用該緩沖區來拷貝資料，下面我們看基準測驗的結果:
BenchmarkCopyWithBufferSize/BufferSize-32768-4 12 116494592 ns/op
BenchmarkCopyWithBufferSize/BufferSize-65536-4 10 110496584 ns/op
BenchmarkCopyWithBufferSize/BufferSize-131072-4 12 87667712 ns/op
從這里看來，32KB大小的緩沖區拷貝一個100M的檔案，需要116494592 ns/op, 而128KB大小的緩沖區拷貝一個100M的檔案，需要87667712 ns/op，不同緩沖區的大小，確實是會對拷貝的性能有一定的影響，
在實際使用中，根據檔案大小、系統資源和性能需求，可以根據需求進行緩沖區大小的調整，較小的檔案通常可以直接使用io.Copy 函式默認的 32KB 緩沖區，而較大的檔案可能需要更大的緩沖區來提高性能，通過合理選擇緩沖區大小，可以獲得更高效的檔案復制操作，
5. 總結
io.Copy 函式是Go語言標準庫提供的一個工具函式，能夠將資料從源Reader復制到目標Writer， 我們先從io.Copy 函式的基本定義出發，之后通過一個簡單的示例，展示如何使用io.Copy 函式實作資料拷貝，
接著我們講述了io.Copy 函式的實作原理，其實就是定義了一個緩沖區，將源Reader資料寫入到緩沖區中，然后再將緩沖區的資料寫入到目標Writer，不斷重復這個程序，實作了資料的拷貝，
在注意事項方面，則強調了及時關閉源Reader和目標Writer的重要性，以及用戶在使用時，需要考慮io.Copy函式的性能是否能夠滿足要求，之后通過基準測驗展示了不同緩沖區大小可能帶來的性能差距，
基于此，完成了對io.Copy 函式的介紹，希望對你有所幫助，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/556871.html
標籤：其他
上一篇：使用 Sa-Token 實作不同的登錄模式：單地登錄、多地登錄、同端互斥登錄
下一篇：返回列表