Wie lese ich Daten variabler Länge aus einer Netzwerkverbindung in Go?

Lesen von Daten variabler Länge in Go mit net.Conn.Read

Bei der Arbeit mit Netzwerkanwendungen in Go stoßen Sie häufig auf Situationen, in denen Die über eine Verbindung empfangenen Daten haben eine variable Länge. net.Conn der Standardbibliothek bietet eine Methode namens Read, die ein Byte-Array mit den empfangenen Daten füllt. Dieser Ansatz kann jedoch problematisch sein, wenn Sie die genaue Länge des Inhalts im Voraus nicht kennen, und kann dazu führen, dass entweder zu viele oder unzureichende Daten gelesen werden.

Um dieser Herausforderung zu begegnen, besteht ein Ansatz darin, das Bufio zu nutzen Paket. Eine effizientere Lösung besteht jedoch darin, einen wachsenden Puffer zu verwenden und Daten zu lesen, bis das Ende der Datei (EOF) erreicht ist:

package main

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

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

    // Write a request to the connection.
    fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

    // Create a buffer to store the received data.
    buf := make([]byte, 0, 4096)

    // Read from the connection in a loop until EOF.
    for {
        // Read into a temporary buffer to avoid overwriting existing data in `buf`.
        tmp := make([]byte, 256)
        n, err := conn.Read(tmp)
        if err != nil {
            if err != io.EOF {
                fmt.Println("read error:", err)
            }
            break
        }

        // Append the new data to the buffer.
        buf = append(buf, tmp[:n]...)
    }

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

Diese Lösung weist einen beträchtlichen Anfangspuffer zu und erweitert ihn schrittweise um mehr Daten werden empfangen. Der Lesevorgang wird fortgesetzt, bis der EOF erreicht ist, wodurch sichergestellt wird, dass der Puffer die vollständige Antwort enthält. Darüber hinaus verfolgt es die Gesamtgröße der empfangenen Daten.

Alternativ können Sie den Typ bytes.Buffer in Verbindung mit io.Copy verwenden, um ein ähnliches Ergebnis zu erzielen:

package main

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

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

    // Write a request to the connection.
    fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

    // Create a buffer to store the received data.
    var buf bytes.Buffer

    // Copy the data from the connection into the buffer.
    io.Copy(&buf, conn)

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

Dieser Ansatz verwendet einen Puffer, der sich bei Bedarf automatisch erweitert und eine sauberere, präzisere Lösung bietet.

Das obige ist der detaillierte Inhalt vonWie lese ich Daten variabler Länge aus einer Netzwerkverbindung in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!