Go语言中http.Get错误处理与nil指针解引用：避免panic的实践指南

// 假设 value 是一个可能导致 http.Get 失败的 URL 字符串
httpRequest, err := http.Get(string(value)) // 发送HTTP GET请求

// 致命错误：此处没有检查 err
// 如果 err 不为 nil (即请求失败)，httpRequest 将为 nil

// 接下来尝试访问 httpRequest.Body
httpRequest.Body.Close() // 如果 httpRequest 为 nil，这里就会 panic
result, readErr := ioutil.ReadAll(httpRequest.Body) // 同理，这里也会 panic

resp, err := http.Get(url) // 发送HTTP GET请求
if err != nil {
    // 立即检查错误。如果请求失败，处理错误并退出当前逻辑
    fmt.Printf("Error fetching URL %s: %v\n", url, err)
    return // 或者 log.Fatal(err), continue 等
}
// 请求成功，resp 不为 nil。现在可以安全地使用 resp 对象

// 使用 defer 确保响应体在函数返回前关闭，释放资源
defer resp.Body.Close()

// 读取响应体
bodyBytes, readErr := ioutil.ReadAll(resp.Body)
if readErr != nil {
    // 读取响应体也可能出错，需要检查
    fmt.Printf("Error reading response body for %s: %v\n", url, readErr)
    return
}

// 此时 bodyBytes 包含了响应数据，可以进行后续处理
// ...

package main

import (
    "bufio"
    "fmt"
    "io"
    "io/ioutil"
    "net/http"
    "os"
    "strconv" // 用于将 int 转换为 string
    "strings" // 用于处理空行
)

func main() {
    fileName := "meinv.txt"
    file, err := os.Open(fileName)
    if err != nil {
        fmt.Printf("Error opening file %s: %v\n", fileName, err)
        return
    }
    defer file.Close() // 确保文件在 main 函数结束时关闭

    var picUrls []string // 更推荐这样初始化切片，避免预分配空字符串
    reader := bufio.NewReader(file)

    for {
        lineBytes, _, err := reader.ReadLine()
        if err == io.EOF {
            break // 文件读取完毕
        }
        if err != nil {
            fmt.Printf("Error reading line from file: %v\n", err)
            return
        }

        line := strings.TrimSpace(string(lineBytes)) // 去除首尾空白符
        if line != "" { // 仅添加非空行
            fmt.Printf("File loaded: %s \n", line)
            picUrls = append(picUrls, line)
        }
    }
    fmt.Printf("File loaded, ready to download %d URLs.\n", len(picUrls))
    fetchPic(picUrls)
}

func fetchPic(picUrls []string) {
    outputDir := "pics"
    // 确保输出目录存在
    if _, err := os.Stat(outputDir); os.IsNotExist(err) {
        err = os.Mkdir(outputDir, 0755)
        if err != nil {
            fmt.Printf("Error creating directory %s: %v\n", outputDir, err)
            return
        }
    }

    for key, value := range picUrls {
        fmt.Printf("Processing URL %d: %s \n", key, value)

        if value == "" {
            fmt.Printf("Skipping empty URL at index %d.\n\n", key)
            continue
        }

        resp, err := http.Get(value)
        if err != nil {
            // 立即处理 http.Get 错误
            fmt.Printf("Error fetching URL %s: %v\n\n", value, err)
            continue // 继续处理下一个URL
        }
        // 确保响应体在函数返回前关闭，释放网络资源
        defer resp.Body.Close() // 注意：这里 defer 会在当前循环迭代结束时执行，而不是整个函数结束。

        // 为了避免在循环中重复 defer 导致资源未及时释放，
        // 更好的做法是将下载逻辑封装到一个单独的函数中，
        // 或者将 defer 放在循环内部的正确位置，确保每次迭代都能及时关闭。
        // 这里为了演示，我们假设在每次循环迭代的末尾处理关闭。
        // 对于大量下载，更好的模式是将下载逻辑放入一个单独的函数：
        // downloadAndSave(value, key, outputDir)
        // 并在该函数内部使用 defer。

        // 检查HTTP状态码，非2xx通常表示请求未成功
        if resp.StatusCode != http.StatusOK {
            fmt.Printf("URL %s returned non-OK status: %s\n\n", value, resp.Status)
            continue
        }

        result, readErr := ioutil.ReadAll(resp.Body)
        if readErr != nil {
            fmt.Printf("Error reading response body for %s: %v\n\n", value, readErr)
            continue
        }

        // 生成文件名，这里使用索引作为文件名，加上 .jpg 后缀
        // 实际应用中，可能需要从URL中解析文件名或生成唯一ID
        filePath := fmt.Sprintf("%s/%s.jpg", outputDir, strconv.Itoa(key))
        writeErr := ioutil.WriteFile(filePath, result, 0644) // 0644 是一个常见的权限设置
        if writeErr != nil {
            fmt.Printf("Error writing file %s: %v\n\n", filePath, writeErr)
            continue
        }

        fmt.Printf("Successfully downloaded and saved %s (length: %d bytes)\n\n", filePath, len(result))
    }
}

func downloadAndSave(url string, index int, outputDir string) error {
    fmt.Printf("Processing URL %d: %s \n", index, url)

    if url == "" {
        return fmt.Errorf("skipping empty URL at index %d", index)
    }

    resp, err := http.Get(url)
    if err != nil {
        return fmt.Errorf("error fetching URL %s: %v", url, err)
    }
    defer resp.Body.Close() // 在此函数返回前关闭 Body

    if resp.StatusCode != http.StatusOK {
        return fmt.Errorf("URL %s returned non-OK status: %s", url, resp.Status)
    }

    result, readErr := ioutil.ReadAll(resp.Body)
    if readErr != nil {
        return fmt.Errorf("error reading response body for %s: %v", url, readErr)
    }

    filePath := fmt.Sprintf("%s/%s.jpg", outputDir, strconv.Itoa(index))
    writeErr := ioutil.WriteFile(filePath, result, 0644)
    if writeErr != nil {
        return fmt.Errorf("error writing file %s: %v", filePath, writeErr)
    }

    fmt.Printf("Successfully downloaded and saved %s (length: %d bytes)\n", filePath, len(result))
    return nil
}

func fetchPic(picUrls []string) {
    // ... (目录创建等)
    for key, value := range picUrls {
        if err := downloadAndSave(value, key, outputDir); err != nil {
            fmt.Printf("Download failed: %v\n\n", err)
        } else {
            fmt.Print("\n") // 增加空行使输出更清晰
        }
    }
}