Comment préserver la taille du tampon lors de la lecture d'octets arbitraires à partir d'une connexion en Go ?

Préserver le tampon lors de la lecture d'octets arbitraires à partir d'une connexion dans Go

Dans les situations où un flux de données doit être lu à partir d'une connexion et plus encore traité en morceaux, un défi courant se pose : gérer des longueurs de flux variables et s'adapter à un nombre d'octets arbitraire.

Considérez l'extrait de code suivant dans lequel un tampon de 256 octets est utilisé pour lire et gérer les données d'une connexion :

buf := make([]byte, 256)
for {
    n, err := conn.Read(buf)
    fmt.Println(string(buf))
    if err != nil || n== 0 {
        return
    }
    Handle(buf[:n])
}

Bien que cette approche fonctionne bien lorsque suffisamment d'octets sont disponibles, elle rencontre des problèmes à la fin du flux, ce qui fait que moins de 256 octets sont lisibles. Pour gérer ce scénario avec élégance, une solution alternative est nécessaire.

Une approche consiste à utiliser un bytes.Buffer, qui fournit un moyen pratique de collecter les données reçues de la connexion. En exploitant bytes.Buffer, le flux complet de données peut être accumulé et transmis au gestionnaire souhaité en une seule opération :

var b bytes.Buffer
if _, err := io.Copy(&b, conn); err != nil {
   return err
}
Handle(b.Bytes())

Avec cette implémentation, la fonction Handle reçoit l'intégralité du flux de données en un seul tranche d'octets, garantissant un traitement transparent quelle que soit sa longueur.

En adoptant cette approche, les développeurs peuvent gérer efficacement les flux de longueur arbitraire, en préservant la taille de tampon souhaitée tout en maintenant l'intégrité des données reçues de la connexion.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!