解决Go语言中Socket读取的EOF错误：正确初始化字节切片

var buf []byte // 此时 buf 的长度和容量都为 0

func problematicRead(conn net.Conn) {
    var buf []byte // 错误：未初始化，长度为 0

    // ... 前面省略了连接建立和写入逻辑 ...

    for {
        readLen, err := conn.Read(buf) // 尝试读取数据到零长度切片
        if err != nil {
            // 如果连接被客户端关闭，这里会立即收到 io.EOF 错误
            // 如果连接未关闭，但 buf 为空，readLen 将为 0，可能也会导致逻辑问题
            fmt.Printf("读取错误或连接关闭: %v\n", err)
            return
        }
        if readLen == 0 {
            fmt.Println("客户端关闭连接")
            return
        }
        // 由于 buf 长度为 0，即使 readLen > 0，这里也无法正确处理数据
        // fmt.Printf("收到数据: %s\n", string(buf[:readLen])) // 这里的 buf[:readLen] 仍然是空的
    }
}

// 语法: make([]Type, length, capacity)
// 对于缓冲区，通常将长度和容量设为相同的值
buf := make([]byte, 1024) // 创建一个长度和容量都为 1024 字节的切片

package main

import (
    "fmt"
    "io"   // 引入 io 包以处理 io.EOF 错误
    "net"  // 引入 net 包进行网络操作
    "os"   // 引入 os 包以访问命令行参数和标准错误输出
)

// handleConnection 处理单个客户端连接
func handleConnection(conn net.Conn) {
    // 确保连接在函数退出时关闭，释放资源
    defer func() {
        fmt.Printf("Closing connection from %s\n", conn.RemoteAddr().String())
        conn.Close()
    }()

    fmt.Printf("Handling connection from %s\n", conn.RemoteAddr().String())

    // 向客户端发送初始消息
    _, err := conn.Write([]byte("Ready to receive. Type something:\n"))
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error writing to client %s: %v\n", conn.RemoteAddr().String(), err)
        return
    }

    // 正确初始化字节切片作为读取缓冲区，分配1024字节的容量
    buf := make([]byte, 1024)

    for {
        // 从连接中读取数据到缓冲区
        // n 是实际读取的字节数，err 是读取过程中遇到的错误
        n, err := conn.Read(buf)
        if err != nil {
            // 如果错误是 io.EOF，表示客户端已关闭连接
            if err == io.EOF {
                fmt.Printf("Client %s disconnected (EOF).\n", conn.RemoteAddr().String())
            } else {
                // 处理其他读取错误
                fmt.Fprintf(os.Stderr, "Error reading from client %s: %v\n", conn.RemoteAddr().String(), err)
            }
            return // 发生错误或EOF时，退出循环，关闭连接
        }

        if n > 0 {
            // 将读取到的字节切片（buf[:n]）转换为字符串并打印
            // 注意：只处理实际读取的 n 个字节，避免处理缓冲区中的旧数据或垃圾数据
            receivedData := buf[:n]
            fmt.Printf("Received %d bytes from %s: '%s'\n", n, conn.RemoteAddr().String(), string(receivedData))

            // 将接收到的数据原样回传给客户端 (Echo)
            _, err = conn.Write(receivedData)
            if err != nil {
                fmt.Fprintf(os.Stderr, "Error echoing data to client %s: %v\n", conn.RemoteAddr().String(), err)
                return
            }
            fmt.Printf("Echoed %d bytes back to %s\n", n, conn.RemoteAddr().String())
        }
        // 如果 n == 0 但 err == nil，这通常不应该发生，或者表示连接在某种奇怪的状态下。
        // 在 TCP 流中，n=0且err=nil通常意味着没有数据可读，但连接仍开放。
        // 但对于阻塞式 Read，如果没有数据，它会阻塞直到有数据或错误。
        // 因此，如果 Read 返回 n=0 且 err=nil，可能是因为 Read 内部处理了某些非致命情况。
        // 在这里，我们主要关注 n > 0 的情况和 err != nil 的情况。
    }
}

// listen 启动TCP监听器并接受传入连接
func listen(serverAddr string) {
    // 创建TCP监听器
    listener, err := net.Listen("tcp", serverAddr)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Could not listen on socket %s: %v\n", serverAddr, err)
        return
    }
    // 确保监听器在函数退出时关闭
    defer listener.Close()
    fmt.Printf("Listening on %s...\n", serverAddr)

    // 循环接受新的客户端连接
    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Fprintf(os.Stderr, "Could not accept connection: %v\n", err)
            // 接受连接失败可能是临时问题，继续尝试接受下一个连接
            continue
        }
        // 为每个新连接启动一个独立的goroutine来处理，实现并发
        go handleConnection(conn)
    }
}

func main() {
    // 从命令行参数获取端口号，如果未提供则使用默认端口8080
    port := "8080"
    if len(os.Args) > 1 {
        port = os.Args[1]
    }
    // 启动监听器，监听所有网络接口的指定端口
    listen(":" + port)

    // 保持主goroutine运行，以便服务器持续监听
    // 在实际应用中，可以使用信号量或通道来优雅地阻塞主goroutine，等待关闭信号
    select {} // 阻塞主goroutine，防止程序退出
}