Go 核心语法与高级实践

package main
import "fmt"

// 核心主入口函数
func main() {
    fmt.Println("Hello, XiaoYu Tech Go Programming!")
}

package main
import "fmt"

func workerEngine(done chan bool) {
    fmt.Println("独立轻量级协程 (Goroutine) 成功开辟，正在执行云端并行运算...")
    done <- true // 向通信管道内灌入控制信号，以此同步告知主协程当前子任务已杀青
}

func main() {
    signalChan := make(chan bool) // 初始化开辟一个强类型的同步无缓冲阻塞双向管道
    go workerEngine(signalChan)   // 使用带有魔法色彩的关键字 go，瞬间并发孵化出一个极轻量的协程
    <-signalChan                  // 主协程执行到此，无条件安全阻塞，静静等待管道信号传回，完美避免进程过早夭折
}

package main
import (
    "encoding/json"
    "fmt"
)

type DeveloperProfile struct {
    Name       string `json:"dev_name"` // 附加元数据标签：指示反射引擎在解析JSON时以此别名建立关系
    TechYears  int    `json:"experience_years"`
    SecretKey  string `json:"-"`        // 指示序列化引擎在输出 JSON 数据时，绝对无条件抹去此隐私字段
}

func main() {
    dev := DeveloperProfile{Name: "萧玉", TechYears: 8, SecretKey: "XIAOYU_PASSPHRASE"}
    jsonBytes, _ := json.Marshal(dev) // 序列化为紧凑的强类型 JSON 字节数组
    fmt.Println(string(jsonBytes))
}

package main
import "fmt"

func main() {
    // 切片是对底层物理固定数组的轻量级虚拟切片包装，可弹性扩容
    techStack := make([]string, 0, 4) // 创建一个长度为0、初始容量限制为4的高速切片
    techStack = append(techStack, "Go", "Rust", "Kubernetes")
    
    fmt.Printf("切片当前实际长度 = %d, 底层物理预留总容量 = %d\n", len(techStack), cap(techStack));
}

package main
import (
    "errors"
    "fmt"
)

func executeDatabaseQuery(sql string) (string, error) {
    if sql == "" {
        return "", errors.New("【核心异常】SQL 命令流为空值，严禁下发核心执行器")
    }
    return "查询记录成功返回", nil // 没有任何异常发生，则按规范回传 nil 空标志
}

func main() {
    result, err := executeDatabaseQuery("")
    if err != nil { // 经典的 Go 风格显式错误哨兵检查防线
        fmt.Println("拦截到系统故障:", err)
        return
    }
    fmt.Println(result)
}

package main
import (
    "fmt"
    "os"
)

func readTechConfig(path string) {
    file, err := os.Open(path)
    if err != nil { return }
    
    // defer 强制声明延迟注册，该语句会被立即塞入当前函数栈的专属私有后进先出（LIFO）延迟链表中
    defer file.Close() // 无论后续发生任何崩溃分支出错，当前函数返回的刹那，此条回收语句必被引爆
    
    fmt.Println("开始安心、安全地读取物理配置文本...")
}

package main
import (
    "fmt"
    "net/http"
)

func homeRouterHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "欢迎访问萧玉技术知识分享！这是一家完全基于 Go 原生高性能网络栈驱动的站点。")
}

func main() {
    // 绑定路由物理节点，内部使用极佳的并发安全 Map 执行 O(1) 匹配
    http.HandleFunc("/", homeRouterHandler)
    // 原生启动监听端口，一旦有TCP连接涌入，自动无条件在底层分配一个专属的独立 Goroutine 应对
    http.ListenAndServe(":8080", nil)
}

package main
import "fmt"

type CryptEngine interface {
    Encrypt(data string) string // 声明契约接口核心行为
}

type AesEngine struct{} // 纯净的实体数据结构体

// 只要该结构体隐式贴合、实现了 CryptEngine 接口定义的所有方法，即自动完成接口契约绑定，完全不需要显式 implement 声明
func (a AesEngine) Encrypt(data string) string {
    return "[AES_CYPHER_STREAM]" + data
}

package main
import "fmt"

type ServerStatus struct {
    MemoryLoad int
}

// 接收者声明为指针类型 *ServerStatus，代表获取原对象的真实物理地址内存卡片
func (s *ServerStatus) RefreshMetrics(newLoad int) {
    s.MemoryLoad = newLoad // 原地安全修改物理实体，绝非临时副本拷贝
}

func main() {
    status := ServerStatus{MemoryLoad: 25}
    status.RefreshMetrics(88) // 隐式自动完成取地址传入
}

package main
import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)
    
    // 运用 select 语法糖，实现高并发多核心通道无死锁的、谁先就绪响应谁的多路复用监听
    select {
    case msg1 := <-ch1:
        fmt.Println("通道1捷足先登:", msg1)
    case msg2 := <-ch2:
        fmt.Println("通道2率先满足:", msg2)
    case <-time.After(time.Second * 3): // 内置防死锁的工业级最高超时硬阻断防线
        fmt.Println("【网络超时中断】两路云端通道均未能及时完成业务响应")
    }
}