Go语言中变量声明与代码结构：var与:=的权衡与最佳实践

package main

import "fmt"

// 包级变量声明
var packageName string = "myPackage"
var packageCounter int

func main() {
    // 函数内部显式声明
    var message string
    message = "Hello, Go!" // 声明后赋值

    var count int = 10     // 声明并初始化

    fmt.Println(packageName, packageCounter) // 输出: myPackage 0
    fmt.Println(message, count)             // 输出: Hello, Go! 10
}

package main

import "fmt"

func main() {
    // 短变量声明
    name := "Alice"         // string类型
    age := 30               // int类型
    isStudent := true       // bool类型

    // 可以在多返回值函数中使用，例如错误处理
    result, err := someFunction()
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println(name, age, isStudent, result)
}

func someFunction() (string, error) {
    return "Operation successful", nil
}

// 示例：一个职责过多的函数
func processComplexWorkflow() {
    // 假设 PackageA.NewT() 和 PackageB.NewT() 返回对应的结构体实例
    a := PackageA.NewT() // 初始化第一个资源
    b := PackageB.NewT() // 初始化第二个资源

    // 执行与a相关的操作
    a.Configure()
    a.Start()

    // 执行与b相关的操作
    b.Prepare()
    b.Execute()

    // 结合a和b进行更多操作
    a.InteractWith(b)
    b.ReportOn(a)

    // 清理资源
    a.Cleanup()
    b.Close()
}

// 改进后的模块化设计
func configureAndStartA(a *PackageA.T) {
    a.Configure()
    a.Start()
}

func prepareAndExecuteB(b *PackageB.T) {
    b.Prepare()
    b.Execute()
}

func interactAndReport(a *PackageA.T, b *PackageB.T) {
    a.InteractWith(b)
    b.ReportOn(a)
}

func cleanupResources(a *PackageA.T, b *PackageB.T) {
    a.Cleanup()
    b.Close()
}

func processComplexWorkflowModular() {
    a := PackageA.NewT() // 局部变量，通过 := 声明和初始化
    b := PackageB.NewT() // 局部变量，通过 := 声明和初始化

    configureAndStartA(a)
    prepareAndExecuteB(b)
    interactAndReport(a, b)
    cleanupResources(a, b)
}

// 良好的命名结合 := 并不影响可读性
userRecord, err := database.GetUserByID(userID) // 明确GetUserByID返回用户记录和错误
if err != nil { /* ... */ }

// 如果变量名不明确，即使有类型也可能难以理解
// var x *models.User
// x, err := database.GetUser(id) // x是什么？

package mypackage

import (
    "fmt"
    "packageA" // 假设存在这些包
    "packageB"
)

// 包级变量，模拟其他语言中的“类成员”或模块共享状态
var m_member1 *packageA.T
var m_member2 *packageB.T

// init 函数用于初始化包级变量
func init() {
    fmt.Println("Initializing mypackage...")
    m_member1 = packageA.NewT() // 假设 NewT 返回 *packageA.T
    m_member2 = packageB.NewT()
    fmt.Println("mypackage initialized.")
}

// 模块化函数，操作包级变量
func DoStuffWithMember1() {
    if m_member1 != nil {
        m_member1.Write()
    }
}

func DoStuffWithMember2() {
    if m_member2 != nil {
        m_member2.Read()
    }
}

// 外部调用示例 (在另一个包的 main 函数中)
/*
package main

import "mypackage"

func main() {
    mypackage.DoStuffWithMember1()
    mypackage.DoStuffWithMember2()
}
*/

package main

import (
    "fmt"
    "packageA"
    "packageB"
)

// 参数化设计示例：函数接收所需资源作为参数
func writeToA(a *packageA.T) {
    fmt.Println("Writing to A:", a)
    a.Write()
}

func readFromB(b *packageB.T) {
    fmt.Println("Reading from B:", b)
    b.Read()
}

// 协调函数，负责资源的创建和传递
func executeWorkflow() {
    // 局部变量，通过 := 声明和初始化
    a := packageA.NewT()
    b := packageB.NewT()

    writeToA(a)
    readFromB(b)
    // ... 更多操作，通过参数传递 a 和 b
}

func main() {
    executeWorkflow()
}

var (
    configPath string
    logger     *log.Logger
)

func init() {
    configPath = os.Getenv("CONFIG_PATH")
    logger = log.New(os.Stdout, "APP: ", log.Ldate|log.Ltime)
}

func processData(data []byte) error {
    // ...
    processedData, err := parseData(data) // 声明并初始化
    if err != nil {
        return fmt.Errorf("failed to parse data: %w", err)
    }

    result := calculateResult(processedData) // 简洁声明
    fmt.Println("Result:", result)

    for i := 0; i < len(data); i++ { // 循环计数器
        // ...
    }
    return nil
}