Go基础语法与控制结构

Go基础语法与控制结构

1. 环境配置与Hello World（扩展）

安装指南

# 验证安装成功
$ go version
# 设置模块代理（中国用户推荐）
$ go env -w GOPROXY=https://goproxy.cn,direct

程序解剖

package main  // 程序入口包声明

import "fmt"  // 格式化IO包

// main函数是程序唯一入口
func main() {
    // Println自动换行且支持Unicode
    fmt.Printf("当前Go版本: %s\n", runtime.Version()) 
}

2. 变量与数据类型（增强）

类型系统全景图

零值机制

var (
    a int     // 0
    b float64 // 0.0
    c string  // ""
    d bool    // false
)

类型别名

type Celsius float64  // 温度类型
var temp Celsius = 36.6

3. 流程控制（增强）

条件语句进阶

// 带作用域的变量声明
if file, err := os.Open("test.txt"); err != nil {
    fmt.Println("打开文件失败:", err)
} else {
    defer file.Close()
    // 处理文件内容
}

Switch黑科技

// 类型判断switch
var val interface{} = 3.14
switch val.(type) {
case int:
    fmt.Println("整数类型")
case float64:
    fmt.Println("双精度浮点")
default:
    fmt.Println("未知类型")
}

// 表达式缺失的switch
score := 85
switch {
case score >= 90:
    fmt.Println("A")
case score >= 80:
    fmt.Println("B")
case score >= 70:
    fmt.Println("C")
}

循环控制全景

// 死循环写法
for {
    // 需要内部break退出
}

// range迭代（后续章节详解）
words := []string{"Go", "Java", "Python"}
for index, word := range words {
    fmt.Printf("%d:%s ", index, word)
}
// 输出：0:Go 1:Java 2:Python

4. 函数定义（增强）

函数特性矩阵

闭包示例

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

c := counter()
fmt.Println(c(), c(), c()) // 1 2 3

错误处理规范

func loadConfig(path string) (*Config, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, fmt.Errorf("配置加载失败: %w", err)
    }
    defer file.Close()
    
    // 解析配置...
    return &config, nil
}

5. 实战演练：温度转换程序

package main

import "fmt"

type Celsius float64
type Fahrenheit float64

func CToF(c Celsius) Fahrenheit {
    return Fahrenheit(c*9/5 + 32)
}

func FToC(f Fahrenheit) Celsius {
    return Celsius((f - 32) * 5 / 9)
}

func main() {
    var c Celsius = 100
    fmt.Printf("%v°C = %v°F\n", c, CToF(c))
    
    f := Fahrenheit(212)
    fmt.Printf("%v°F = %v°C\n", f, FToC(f))
}

graph TD
    A[开始] --> B[输入温度值]
    B --> C{选择转换方向}
    C -->|C→F| D[调用CToF函数]
    C -->|F→C| E[调用FToC函数]
    D --> F[输出结果]
    E --> F
    F --> G[结束]

Go复合类型与内存管理

1. 数组与切片（增强）

底层关系图解

切片扩容机制

s := []int{1,2,3}
fmt.Printf("原始容量: %d\n", cap(s)) // 3

s = append(s, 4)
fmt.Printf("扩容后容量: %d\n", cap(s)) // 6（Go 1.18+策略）

2. 映射与结构体（增强）

嵌套结构体

type Address struct {
    City    string
    ZipCode int
}

type User struct {
    Name    string
    Age     int
    Address // 匿名嵌入
}

func main() {
    u := User{
        Name: "张三",
        Age:  25,
        Address: Address{
            City:    "北京",
            ZipCode: 100000,
        },
    }
    fmt.Println(u.City) // 直接访问匿名字段
}

3. 接口与反射（新增章节）

接口实现原理

类型断言示例

var val interface{} = "hello"

if s, ok := val.(string); ok {
    fmt.Println(s)
} else {
    fmt.Println("不是字符串类型")
}

​实战项目建议​：尝试开发一个简单的学生管理系统，要求：

• 使用结构体存储学生信息（姓名、学号、成绩）
• 使用切片实现数据存储
• 实现增删改查功能
• 支持数据持久化存储

建议配合官方文档 https://golang.org/doc 进行深入学习。