Go语言包可见性深度解析：理解“子包”的真相

myproject/
├── foo/
│   └── main.go
└── foo/utils/
    └── utils.go

package utils

import "fmt"

// exportedFunction 是一个导出的函数，因为它以大写字母开头
func ExportedFunction() {
    fmt.Println("This is an exported function from utils package.")
    unexportedHelper() // 可以在包内部调用非导出函数
}

// unexportedFunction 是一个非导出的函数，因为它以小写字母开头
func unexportedHelper() {
    fmt.Println("This is an unexported helper function within utils package.")
}

// ExportedVariable 是一个导出的变量
var ExportedVariable = "I am an exported variable."

// unexportedVariable 是一个非导出的变量
var unexportedVariable = "I am an unexported variable."

// ExportedStruct 是一个导出的结构体
type ExportedStruct struct {
    Field1 string // 导出的字段
    field2 string // 非导出的字段
}

// unexportedStruct 是一个非导出的结构体
type unexportedStruct struct {
    Data string
}

package main

import (
    "fmt"
    "myproject/foo/utils" // 导入utils包
)

func main() {
    fmt.Println("--- 尝试访问 utils 包的成员 ---")

    // 1. 访问导出的函数 (成功)
    utils.ExportedFunction()

    // 2. 尝试访问非导出的函数 (编译错误)
    // utils.unexportedHelper() // 编译错误: utils.unexportedHelper is not exported

    // 3. 访问导出的变量 (成功)
    fmt.Printf("Exported variable: %s\n", utils.ExportedVariable)

    // 4. 尝试访问非导出的变量 (编译错误)
    // fmt.Printf("Unexported variable: %s\n", utils.unexportedVariable) // 编译错误: utils.unexportedVariable is not exported

    // 5. 使用导出的结构体 (成功)
    myStruct := utils.ExportedStruct{Field1: "Hello"}
    fmt.Printf("Exported struct field: %s\n", myStruct.Field1)
    // myStruct.field2 = "World" // 编译错误: myStruct.field2 is not exported

    // 6. 尝试使用非导出的结构体 (编译错误)
    // var myUnexportedStruct utils.unexportedStruct // 编译错误: utils.unexportedStruct is not exported
}