func Copy(dst io.Writer, src io.Reader) (written int64, err error)

package main
import (
        "fmt"
        "io"
        "os"
)
func main() {
        fmt.Print("請輸入一個字符串：")
        src := readString()
        // 通過io.Copy 函數(shù)能夠?qū)?src 的全部數(shù)據(jù) 拷貝到 控制臺上輸出
        written, err := io.Copy(os.Stdout, src)
        if err != nil {
                fmt.Println("復(fù)制過程中發(fā)生錯誤：", err)
                return
        }
        fmt.Printf("\n成功復(fù)制了 %d 個字節(jié)。\n", written)
}
func readString() io.Reader {
   buffer := make([]byte, 1024)
   n, _ := os.Stdin.Read(buffer)
   // 如果實際讀取的字節(jié)數(shù)少于切片長度，則截取切片
   if n < len(buffer) {
      buffer = buffer[:n]
   }
   return strings.NewReader(string(buffer))
}

func Copy(dst Writer, src Reader) (written int64, err error) {
   // Copy 函數(shù) 調(diào)用了 copyBuffer 函數(shù)來實現(xiàn)
   return copyBuffer(dst, src, nil)
}
func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
   // 如果 源Reader 實現(xiàn)了 WriterTo 接口,直接調(diào)用該方法 將數(shù)據(jù)寫入到 目標(biāo)Writer 當(dāng)中
   if wt, ok := src.(WriterTo); ok {
      return wt.WriteTo(dst)
   }
   // 同理，如果 目標(biāo)Writer 實現(xiàn)了 ReaderFrom 接口,直接調(diào)用ReadFrom方法
   if rt, ok := dst.(ReaderFrom); ok {
      return rt.ReadFrom(src)
   }
   // 如果沒有傳入緩沖區(qū)，此時默認 創(chuàng)建一個 緩沖區(qū)
   if buf == nil {
      // 默認緩沖區(qū) 大小為 32kb
      size := 32 * 1024
      // 如果源Reader 為LimitedReader, 此時比較 可讀數(shù)據(jù)數(shù) 和 默認緩沖區(qū)，取較小那個
      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 {
      // 調(diào)用Read方法 讀取數(shù)據(jù)
      nr, er := src.Read(buf)
      if nr > 0 {
         // 將數(shù)據(jù)寫入到 目標(biāo)Writer 當(dāng)中
         nw, ew := dst.Write(buf[0:nr])
         // 判斷寫入是否 出現(xiàn)了 錯誤
         if nw < 0 || nr < nw {
            nw = 0
            if ew == nil {
               ew = errInvalidWrite
            }
         }
         // 累加 總寫入數(shù)據(jù)
         written += int64(nw)
         if ew != nil {
            err = ew
            break
         }
         // 寫入字節(jié)數(shù) 小于 讀取字節(jié)數(shù),此時報錯
         if nr != nw {
            err = ErrShortWrite
            break
         }
      }
      if er != nil {
         if er != EOF {
            err = er
         }
         break
      }
   }
   return written, err
}

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
        }
        // 調(diào)用Close方法
        defer src.Close()
        // 創(chuàng)建目標(biāo)文件
        dst, err := os.Create(destinationFile)
        if err != nil {
                fmt.Println("無法創(chuàng)建目標(biāo)文件:", err)
                return
        }
        // 調(diào)用Close 方法
        defer dst.Close()
        // 執(zhí)行文件復(fù)制
        _, err = io.Copy(dst, src)
        if err != nil {
                fmt.Println("復(fù)制文件出錯:", err)
                return
        }
        fmt.Println("文件復(fù)制成功!")
}

func BenchmarkCopyWithBufferSize(b *testing.B) {
   // 本地運行時, 文件大小為 100 M
   filePath := "largefile.txt"
   bufferSizes := []int{32 * 1024, 64 * 1024, 128 * 1024} // 不同的緩沖區(qū)大小
   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")
         }
      })
   }
}