io.Copy 函數是一個非常好用的函數，能夠非常方便得將資料進行拷貝。本文我們將從io.Copy 函數的基本定義出發，講述其基本使用和實現原理，以及一些注意事項，基於此完成對io.Copy 函數的介紹。
Copy函數用於將資料從源（io.Reader）複製到目標（io.Writer）。它會持續複製直到源中的資料全部讀取完畢或發生錯誤，並返回複製的位元組數和可能的錯誤。函數定義如下:
func Copy(dst io.Writer, src io.Reader) (written int64, err error)
其中dst 為目標寫入器，用於接收源資料；src則是源讀取器，用於提供資料。
下面提供一個使用 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函數，程式最終會將字串列印到終端上。
在瞭解了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， 如此往復，直到資料全部讀取完成。
在使用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關閉系統資源。
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 緩衝區，而較大的檔案可能需要更大的緩衝區來提高效能。通過合理選擇緩衝區大小，可以獲得更高效的檔案複製操作。
io.Copy 函數是Go語言標準庫提供的一個工具函數，能夠將資料從源Reader複製到目標Writer。 我們先從io.Copy 函數的基本定義出發，之後通過一個簡單的範例，展示如何使用io.Copy 函數實現資料拷貝。
接著我們講述了io.Copy 函數的實現原理，其實就是定義了一個緩衝區，將源Reader資料寫入到緩衝區中，然後再將緩衝區的資料寫入到目標Writer，不斷重複這個過程，實現了資料的拷貝。
在注意事項方面，則強調了及時關閉源Reader和目標Writer的重要性。以及使用者在使用時，需要考慮io.Copy函數的效能是否能夠滿足要求，之後通過基準測試展示了不同緩衝區大小可能帶來的效能差距。
基於此，完成了對io.Copy 函數的介紹，希望對你有所幫助。