Lecture spécifique nombre d'octets à partir d'un tampon lecteur dans golang

Je suis conscient de la fonction spécifique dans golang de la bufio paquet.

func (b *Reader) Peek(n int) ([]byte, error)

Peek retourne le prochain n octets sans faire avancer le lecteur. Les octets
cesser d'être valide à la prochaine lecture appel. Si Peek renvoie moins de n
octets, il renvoie une erreur expliquant pourquoi la lecture est courte. L'
l'erreur est ErrBufferFull si n est plus grand que b est la taille de la mémoire tampon.

J'ai besoin d'être capable de lire un nombre déterminé d'octets à partir d'un Lecteur de avance le lecteur. Fondamentalement, identique à la fonction ci-dessus, mais il avance le lecteur. Quelqu'un sait comment faire cela?

InformationsquelleAutor Kirk Backus | 2012-12-01

bufferedreader go peek

21
```
func (b *Reader) Read(p []byte) (n int, err error)
```
http://golang.org/pkg/bufio/#Reader.Read

Le nombre d'octets lus sera limitée à len(p)
- Ce ne sera pas "toujours" lire un nombre spécifique d'octets cependant, il ne fera que limiter les octets lus à len(p).
InformationsquelleAutor Chris
67

Noter que le bufio.Read les appels de méthode sous-jacents io.Read plus d'une fois, ce qui signifie qu'il peut retourner n < len(p), sans atteindre des expressions du FOLKLORE. Si vous voulez lire exactement len(p) octets ou échouer avec une erreur, vous pouvez utiliser io.ReadFull comme ceci:
```
n, err := io.ReadFull(reader, p)
```
Cela fonctionne même si le lecteur est mis en mémoire tampon.
- Ce doit être la accepté de répondre. Élimine la lancinante doute d'un "court" lire c'est à dire pas besoin de boucle et de vérification pour les io.Expressions du FOLKLORE, etc. Doc un bon exemple ici aussi: golang.org/pkg/io/#ReadFull
- Peut-être qu'il est intéressant de noter que io.ReadFull est juste un wrapper pour cet appel: io.ReadAtLeast(reader, p, len(p)) Également dans le cas de io.ReadFull vous devez d'abord définir le p avec sa longueur est égale à la taille d'octets que vous souhaitez lire, mais pour io.ReadAtLeast la longueur de la p peut être que tant qu'il est plus grand que ou égal à la taille que vous souhaitez lire.
InformationsquelleAutor monicuta

Je suis en préférant Lire (), surtout si vous vous apprêtez à lire n'importe quel type de fichiers, et il pourrait être également utile à l'envoi de données en morceaux, ci-dessous est un exemple pour montrer comment il est utilisé

fs, err := os.Open("fileName"); 

if err != nil{
    fmt.Println("error reading file")
    return
}

defer fs.Close()

reader := bufio.NewReader(fs)

buf := make([]byte, 1024)

for{
    v, _ := reader.Read(buf) //ReadString and ReadLine() also applicable or alternative

    if v == 0{
        return
    }
    //in case it is a string file, you could check its content here...
    fmt.Print(string(buf))
}

InformationsquelleAutor msoliman

3

Passer un n-octets de taille de la mémoire tampon pour le lecteur.

InformationsquelleAutor zzzz
0

Pour ce faire, il vous suffit de créer un octet tranche et lire les données dans cette tranche avec
```
n := 512
buff := make([]byte, n)
fs.Read(buff)  //fs is your reader. Can be like this fs, _ := os.Open('file')
```
func (b *Reader) Read(p []byte) (n int, err error)

Lecture lit les données dans p. Elle renvoie le nombre d'octets lus en p.
Les octets sont pris depuis plus d'un Lire sur le Lecteur,
donc n peut être inférieure à len(p)

InformationsquelleAutor Salvador Dali

TLDR:

my42bytes, err := ioutil.ReadAll(io.LimitReader(myReader, 42))

Réponse complète:

@monicuta mentionné io.ReadFull qui fonctionne très bien. Ici je fournir une autre méthode. Il fonctionne en chaînage ioutil.ReadAll et io.LimitReader ensemble. Nous allons lire la doc d'abord:

$ go doc ioutil.ReadAll
func ReadAll(r io.Reader) ([]byte, error)
     ReadAll reads from r until an error or EOF and returns the data it read. A
     successful call returns err == nil, not err == EOF. Because ReadAll is
     defined to read from src until EOF, it does not treat an EOF from Read as an
     error to be reported. 

$ go doc io.LimitReader
func LimitReader(r Reader, n int64) Reader
     LimitReader returns a Reader that reads from r but stops with EOF after n
     bytes. The underlying implementation is a *LimitedReader.

Donc, si vous voulez obtenir 42 octets de myReader, vous le faites

import (
        "io"
        "io/ioutil"
)

func main() {
        //myReader := ...
        my42bytes, err := ioutil.ReadAll(io.LimitReader(myReader, 42))
        if err != nil {
                panic(err)
        }
        //...
}

Voici le code équivalent avec io.ReadFull

$ go doc io.ReadFull
func ReadFull(r Reader, buf []byte) (n int, err error)
    ReadFull reads exactly len(buf) bytes from r into buf. It returns the number
    of bytes copied and an error if fewer bytes were read. The error is EOF only
    if no bytes were read. If an EOF happens after reading some but not all the
    bytes, ReadFull returns ErrUnexpectedEOF. On return, n == len(buf) if and
    only if err == nil. If r returns an error having read at least len(buf)
    bytes, the error is dropped.

import (
        "io"
)

func main() {
        //myReader := ...
        buf := make([]byte, 42)
        _, err := io.ReadFull(myReader, buf)
        if err != nil {
                panic(err)
        }
        //...
}

Par rapport à io.ReadFull, l'avantage est que vous n'avez pas besoin de configurer manuellement un buf, où len(buf) est le nombre d'octets que vous voulez lire, puis passer buf comme argument quand vous Lisez

Au lieu de cela il vous suffit de dire io.LimitReader que vous voulez à la plupart des 42 octets de myReader, et d'appeler ioutil.ReadAll de les lire tous, de retourner le résultat sous forme d'une tranche d'octets. En cas de succès, le retour de la tranche est garanti d'être de la longueur de 42.

InformationsquelleAutor navigaid

Vous devez vous connecter pour publier un commentaire.