Comment lire des données en morceaux à partir d'un « net.Conn » dans Go ?

Lecture de données en morceaux avec net.Conn.Read de Go

Dans Go, vous pouvez accéder aux connexions réseau brutes à l'aide de net.Conn.Read, qui lit les paquets de données entrants dans un tableau d'octets. Cependant, lorsque vous ne connaissez pas la taille exacte des données entrantes, la lecture dans un tableau de taille fixe peut entraîner une troncature des données ou une mise en mémoire tampon inutile.

Pour gérer cela, vous pouvez utiliser une approche plus flexible en utilisant le package bufio ou des techniques alternatives.

Utiliser bufio

Le package bufio fournit le type Reader, qui vous permet de lire les données en morceaux. Vous pouvez créer un objet Reader à partir de votre connexion net.Conn, puis utiliser les méthodes ReadSlice ou ReadBytes pour lire les données jusqu'à ce qu'un délimiteur spécifique soit rencontré ou que la fin de l'entrée soit atteinte. Par exemple, pour lire les données jusqu'à la fin du paquet, vous pouvez utiliser le code suivant :

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    conn, err := net.Dial("tcp", "google.com:80")
    if err != nil {
        fmt.Println("dial error:", err)
        return
    }
    defer conn.Close()

    // Create a bufio.Reader from the net.Conn
    reader := bufio.NewReader(conn)

    // Read data in chunks until the end of the packet
    buf := []byte{}
    for {
        chunk, err := reader.ReadSlice('\n')
        if err != nil {
            if err != io.EOF {
                fmt.Println("read error:", err)
            }
            break
        }
        buf = append(buf, chunk...)
    }
    fmt.Println("total size:", len(buf))
    // fmt.Println(string(buf))
}

Approche alternative

Vous pouvez également utiliser le type bytes.Buffer pour ajouter les données entrantes. morceaux de données et accumuler la taille totale :

package main

import (
    "bytes"
    "fmt"
    "io"
    "net"
)

func main() {
    conn, err := net.Dial("tcp", "google.com:80")
    if err != nil {
        fmt.Println("dial error:", err)
        return
    }
    defer conn.Close()

    // Create a bytes.Buffer to accumulate incoming data
    var buf bytes.Buffer

    // Copy data from the net.Conn to the Buffer
    if _, err = io.Copy(&buf, conn); err != nil {
        fmt.Println("copy error:", err)
    }

    fmt.Println("total size:", buf.Len())
}

En utilisant l'une de ces approches, vous pouvez gérer différentes longueurs de données sans troncature de données ni mise en mémoire tampon excessive, garantissant ainsi un transfert de données efficace sur les connexions réseau dans Go.

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!