Question

我不理解错误，这是我在机器中执行的主要内容＆＃34; A＆＃34;：

package main

import (
    "fmt"
    "net"
    "os"
    "github.com/mistifyio/go-zfs"
)

func main() {
    // Listen for incoming connections.
    l, err := net.Listen("tcp", "192.168.99.5:9977")
    if err != nil ...
    // Close the listener when the application closes.
    defer l.Close()
    fmt.Println("Listening on " + CONN_HOST + ":" + CONN_PORT)
    for {
        // Listen for an incoming connection.
        conn, err := l.Accept()
        if err != nil ...

        //Handle connections in a new goroutine.
        go handleRequest(conn)
    }
}

// Handles incoming requests.
func handleRequest(conn net.Conn) {
    // Make a buffer to hold incoming data.
    buff := make([]byte, 1024)
    // Read the incoming connection into the buffer.
    _, err := conn.Read(buff)
    if err != nil {
        fmt.Printf("Error reading: %s.\n", err.Error())
    }
    // ReceiveSnapshot
    ds, err := zfs.ReceiveSnapshot(buff, "tank/replication")
    if err != nil {
        fmt.Printf("Error receiving: %s.\n", err.Error())
    }
    fmt.Printf("%s... done!\n", ds)
    // Send a response back to person contacting us.
    conn.Write([]byte("Received!"))
    // Close the connection when you're done with it.
    conn.Close()
}

现在，我向您展示来自github.com/mistifyio/go-zfs/zfs.go的函数ReceiveSnapshot：

type command struct {
    Command string
    Stdin   io.Reader
    Stdout  io.Writer
}

func ReceiveSnapshot(input io.Reader, name string) (*Dataset, error) {
    c := command{Command: "zfs", Stdin: input}
    _, err := c.Run("receive", name)
    if err != nil {
        return nil, err
    }
    return GetDataset(name)
}

我在golang pkg中看到了io.Reader的文档：

type Reader interface {
        Read(p []byte) (n int, err error)
}

为什么我收到错误...

不能使用buff（type [] byte）作为zfs.ReceiveSnapshot参数中的io.Reader类型： [] byte没有实现io.Reader（缺少Read方法）

...当我go install时？

Answer 1

我认为，当您认为[]byte等同于Reader只是因为读者的Read方法收到[]byte时，您错过了逻辑中的一步参数。

让我试着澄清一下：

您的ReceiveSnapshot函数需要Reader作为参数：

ReceiveSnapshot( input io.Reader ...

为了使类型满足Reader接口，该类型本身应该实现此功能：

Read(p []byte) (n int, err error)

请注意，该类型应该实现该功能才能成为Reader。

[]byte 未实现 Read功能。 Read的论点恰好是[]byte。

，这简直是巧合

为了实现这一点，您需要发送ReceiveSnapshot正确的Reader。

幸运的是，拥有[]byte并希望阅读它是一种常见情况，因此API提供了一种简单的方法：

https://golang.org/pkg/bytes/#NewReader

您只需将bytes.NewReader(buff)发送到ReceiveSnapshot功能，而不只是buff。

Answer 2

简短答案：使用Reader

将缓冲区包装为bytes.NewReader类型

或者，您可以使用bytes.NewBuffer来达到类似的效果。

如果源是字符串，则可以使用strings.NewReader。

读者列表不停地出现：https://golang.org/search?q=Read#Global

对更深层问题的解释

更深层的问题是：为什么数组不直接支持io.Reader接口？

io.Reader支持从通用数据流中读取数据的概念，对于该数据流，总大小不一定是预先已知的。为了支持这一点，Read被反复调用，直到所有输入数据都用完为止。在许多语言中，相似的读取函数必须至少调用两次，最终调用将返回一个标志，指示文件结束。

通过返回两个值（其中一个类型为error），Go使得可以一次完成读取数组的操作，，但前提是目标缓冲区足够大以消耗所有内存可用数据-并不总是事先知道的。

io.Reader接口指定Read()函数的签名和行为：

func (T) Read(b []byte) (n int, err error)

Read使用数据填充给定的字节片，并返回填充的字节数和错误值。流结束时，它将返回io.EOF错误。

因此，由于io.Reader接口的工作方式，简单的字节缓冲区无法实现它。需要一个包装器结构，以便记住对Read()的后续调用之间的状态。

为了有趣，下面是一个示例，显示了如何实现...

type MyReader struct {
    src []byte
    pos int
}

func (r *MyReader) Read(dst []byte) (n int, err error) {
    n = copy(dst, r.src[r.pos:])
    r.pos += n
    if r.pos == len(r.src) {
        return n, io.EOF
    }
    return
}

func NewMyReader(b []byte) *MyReader { return &MyReader{b, 0} }

还请注意，[]byte的{{1}}参数是目标缓冲区，而不是源缓冲区。

不能使用（类型[] byte）作为类型io.Reader

2 个答案:

对更深层问题的解释