Ottenere il messaggio di errore "bytes.Buffer non implementa io.Writer"

Sto cercando di fare in modo che un oggetto Go implementi io.Writer, ma scrive su una stringa anziché su un file o su un oggetto simile a un file. Ho pensato che bytes.Bufferavrebbe funzionato poiché implementa Write(p []byte). Tuttavia, quando provo questo:

import "bufio"
import "bytes"

func main() {
    var b bytes.Buffer
    foo := bufio.NewWriter(b)
}

Ottengo il seguente errore:

cannot use b (type bytes.Buffer) as type io.Writer in function argument:
bytes.Buffer does not implement io.Writer (Write method has pointer receiver)

Sono confuso, poiché implementa chiaramente l'interfaccia. Come risolvo questo errore?

Passa un puntatore al buffer, invece del buffer stesso:

import "bufio"
import "bytes"

func main() {
    var b bytes.Buffer
    foo := bufio.NewWriter(&b)
}

package main

import "bytes"
import "io"

func main() {
    var b bytes.Buffer
    _ = io.Writer(&b)
}

Non è necessario utilizzare "bufio.NewWriter (& b)" per creare un io.Writer. & b è un io.Writer stesso.

Basta usare

foo := bufio.NewWriter(&b)

Perché il modo in cui bytes.Buffer implementa io.Writer è

func (b *Buffer) Write(p []byte) (n int, err error) {
    ...
}
// io.Writer definition
type Writer interface {
    Write(p []byte) (n int, err error)
}

Non lo b *Bufferè b Buffer. (Penso anche che sia strano perché possiamo chiamare un metodo da una variabile o dal suo puntatore, ma non possiamo assegnare un puntatore a una variabile di tipo non puntatore.)

Inoltre, il prompt del compilatore non è abbastanza chiaro:

bytes.Buffer does not implement io.Writer (Write method has pointer receiver)

Alcune idee, usate da Go Passed by value, se passiamo ba buffio.NewWriter(), in NewWriter (), è un nuovo b(un nuovo buffer), non il buffer originale che abbiamo definito, quindi dobbiamo passare l'indirizzo &b.

Aggiungi di nuovo, byte. Il buffer è definito:

type Buffer struct {
    buf       []byte   // contents are the bytes buf[off : len(buf)]
    off       int      // read at &buf[off], write at &buf[len(buf)]
    bootstrap [64]byte // memory to hold first slice; helps small buffers avoid allocation.
    lastRead  readOp   // last read operation, so that Unread* can work correctly.
}

utilizzando passed by value, la nuova struttura del buffer passata è diversa dalla variabile del buffer di origine.