为什么Go会根据我声明缓冲区的位置设置不同的内容类型

我尝试了热气腾腾的视频，但无法解释以下行为。 我从Go的net/http服务器、从两个不同的处理程序获得不同的响应头，唯一的区别是我在哪里声明缓冲区

在下面的代码中有两个处理程序，其中唯一的区别是一个处理程序在本地声明缓冲区。在该版本中，流式处理工作正常，Chrome流式处理视频，我看到它通过传输编码得到响应：分块，内容类型：video/mp4

在第二个版本中，缓冲区是一个输入参数，Chrome不会对视频进行流处理，并且标题也不同

package main

import (
    "bytes"
    "io"
    "log"
    "net/http"
    "os"
)

func main() {
    file := "/Users/someUser/Documents/Zoom/Ronen/zoom_0.mp4"

    f, err := os.Open(file)
    defer f.Close()

    if err != nil {
        log.Fatalln(err)
    }
    http.ListenAndServe(":9008", GetVidHandler(f))
}

//This implementation works, buff is declared locally.
//I get header of content-type video/mp4
func GetVidHandler(f *os.File) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        offset := int64(0)
        var buff [4096]byte
        for {
            n, _ := f.ReadAt(buff[:], offset)
            offset += int64(n)
            re := bytes.NewReader(buff[:])
            io.Copy(w, re)
        }
    }
}

//This implementation doesn't stream, buff is input param
//I get header of content-type octet-stream
func GetVidHandler(f *os.File, buff [4096]byte) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        offset := int64(0)
        for {
            n, _ := f.ReadAt(buff[:], offset)
            offset += int64(n)
            re := bytes.NewReader(buff[:])
            io.Copy(w, re)
        }
    }
}

---

感谢您的评论，但修复它们仍然不会改变行为。 例如，以下代码得到
写入tcp 127.0.0.1:9008->127.0.0.1:60443:写入：断开的管道

package main

import (
    "bytes"
    "io"
    "log"
    "net/http"
    "os"
)

type Viewer struct {
    ch   chan []byte
    buff [3][4096]byte
}

func main() {
    file := "/Users/someUSer/Documents/Zoom/Ronen/zoom_0.mp4"

    f, err := os.Open(file)
    defer f.Close()

    if err != nil {
        log.Fatalln(err)
    }

    m := make(map[int]*Viewer)
    start := make(chan struct{})

    go func() {

        offset := int64(0)
        <-start
        log.Println("Starting...")
        i := 0
        for {
            var b [4096]byte
            n, err := f.ReadAt(b[:], offset)
            if err != nil {
                log.Println(err)
                return
            }

            offset += int64(n)
            for _, v := range m {
                copy(v.buff[i%3][:], b[:n])
                v.ch <- v.buff[i%3][:n]
            }
            i++
        }

    }()

    http.ListenAndServe(":9008", GetVidHandler(m, start))

}

func GetVidHandler(m map[int]*Viewer, start chan struct{}) http.HandlerFunc {

    i := 0

    return func(w http.ResponseWriter, r *http.Request) {

        current := i
        v := &Viewer{ch: make(chan []byte)}
        m[current] = v
        i++
        select {
        case start <- struct{}{}:
        default:

        }
        cn, ok := w.(http.CloseNotifier)
        if !ok {
            http.NotFound(w, r)
            return
        }
        // flusher, ok := w.(http.Flusher)
        // if !ok {
        //  http.NotFound(w, r)
        //  return
        // }

        // Send the initial headers saying we're gonna stream the response.
        // w.Header().Set("Transfer-Encoding", "chunked")
        // w.Header().Set("Content-Type", "video/mp4")
        // w.WriteHeader(http.StatusOK)
        // // flusher.Flush()

        // b := <-v.ch
        // log.Println(current, "-Writing ", len(b), " Bytes")
        // log.Printf("%d - WRITE - First 100 bytes %v\n", current, b[:100])
        // w.Write(b[:len(b)])

        // flusher.Flush()
        for {
            select {
            case <-cn.CloseNotify():
                log.Println("Client stopped listening")
                return
            default:
                b := <-v.ch
                re := bytes.NewReader(b[:])
                _, err := io.Copy(w, re)
                if err != nil {
                    log.Println(err)

                }
            }
        }

    }

}

//Works
// func GetVidHandler(f *os.File) http.HandlerFunc {

//  return func(w http.ResponseWriter, r *http.Request) {
//      offset := int64(0)
//      var buff [4096]byte
//      for {
//          n, _ := f.ReadAt(buff[:], offset)
//          log.Printf("WRITE - First 100 bytes %v\n", buff[:100])

//          offset += int64(n)
//          re := bytes.NewReader(buff[:])
//          io.Copy(w, re)
//      }
//  }

// }

主程序包
进口(
“字节”
“io”
“日志”
“net/http”
“操作系统”
)
类型查看器结构{
ch chan[]字节
buff[3][4096]字节
}
func main（）{
文件：=“/Users/someUSer/Documents/Zoom/Ronen/Zoom_0.mp4”
f、 错误：=os.Open（文件）
延迟f.关闭（）
如果错误！=零{
log.Fatalln（错误）
}
m:=make（映射[int]*Viewer）
开始：=make（chan结构{}）
go func（）{
偏移量：=int64（0）
在读取之后，您不能使用buff pass n。只要有一个读取比以前的任何读取都要短，您就在复制垃圾。此外，在第二个版本中，并发请求会相互攻击，因为它们使用相同的缓冲区空间。如果favicon请求搞砸了事情，我不会感到惊讶。添加到以前的通信ents：两个处理程序都不存在。通过在读取错误时中断循环来修复。bytes.NewReader/io.Copy代码可以简化为
w.Write（buff[：n]）
（这也修复了第一条注释中提到的问题）。最好的修复方法是使用。