Go语言中多返回值函数的优雅处理与选择性访问策略

func fetchData() (string, error) {
    // 模拟数据获取操作
    data := "some data"
    var err error // 实际中可能返回非nil错误
    return data, err
}

data, err := fetchData()
if err != nil {
    // 处理错误
    panic(err)
}
fmt.Println("Fetched data:", data)

// 期望的（但不支持的）语法：
// value := fetchData()[0] // 错误：Go不支持直接索引函数返回的元组

func processData(s string) {
    fmt.Println("Processing:", s)
}

func main() {
    // 传统的处理方式，即使只用一个值
    data, _ := fetchData() // 忽略错误，但通常不推荐
    processData(data)
}

// 原始函数，可能返回错误
// func Parse(name, text string) (*Template, error)

// template.Must 的简化实现概念
func Must(t *template.Template, err error) *template.Template {
    if err != nil {
        panic(err)
    }
    return t
}

// 使用方式
// tmpl := template.Must(template.New("name").Parse("Hello, {{.}}!"))

package main

import (
    "errors"
    "fmt"
)

type Config struct {
    Setting string
}

// 模拟解析配置的函数，可能返回错误
func ParseConfig(data string) (*Config, error) {
    if data == "" {
        return nil, errors.New("config data cannot be empty")
    }
    return &Config{Setting: "Parsed: " + data}, nil
}

// MustParseConfig 是一个辅助函数，用于处理 ParseConfig 的返回值
// 如果解析失败，它将导致程序 panic
func MustParseConfig(data string) *Config {
    cfg, err := ParseConfig(data)
    if err != nil {
        panic(fmt.Sprintf("failed to parse config: %v", err))
    }
    return cfg
}

func main() {
    // 使用 MustParseConfig，无需显式检查错误
    // 如果配置数据为空，程序会 panic
    config1 := MustParseConfig("some_settings")
    fmt.Println("Config 1 setting:", config1.Setting)

    // 演示错误情况，这将导致 panic
    // config2 := MustParseConfig("")
    // fmt.Println("Config 2 setting:", config2.Setting)
}

package main

import "fmt"

func getTwoInts() (int, int) {
    return 10, 20
}

// GetSecondInt 辅助函数，专门用于获取 getTwoInts 返回的第二个值
func GetSecondInt() int {
    _, second := getTwoInts()
    return second
}

func main() {
    val := GetSecondInt()
    fmt.Println("Second value:", val) // 输出: Second value: 20
}