Go语言入门：程序结构与基础数据类型详解

1. 程序结构与命名规范

Go语言的程序由包（Package）组成，代码的可见性严格依赖名称的大小写。掌握正确的命名方式是编写模块化、可复用代码的第一步。

第1步：理解作用域与导出规则

在函数内部声明的实体仅在该局部有效；在函数外声明的实体则对同包内所有源文件可见。跨包的可见性取决于首字母：

• 大写开头（如 FanOne）：表示该实体已导出（Exported），其他包的代码可以通过导入当前包来访问和引用它。
• 小写开头（如 fanOne）：未导出，仅在当前包内部使用。

上述代码展示了导出的函数或变量可以被外部调用。

而私有变量若尝试从包外访问，编译器会报错，防止了不必要的暴露。

第2步：采用驼峰式命名风格

Go社区广泛采用驼峰命名法。一般遵循“局部变量用小驼峰，导出标识用大驼峰”的习惯。

func main() {
    FanOne := "666" // 大驼峰：通常用于需导出的函数名或全局变量
    fanOne := "666" // 小驼峰：通常用于局部变量或私有字段
}

虽然允许使用中划线或下划线，但为了保持代码风格的一致性，强烈建议统一使用驼峰命名。

第3步：变量的声明与初始化

声明变量有两种主要方式：var 关键字和短变量声明运算符 :=。

• var 声明：可以显式指定类型，适合需要默认值的场景。
• := 短声明：编译器自动推断类型，通常在函数体内使用。

// var 形式
var fanOne string
var xiaoSheng int
var a, b, c = true, 6.6, "fanOne" // 混合类型：bool, float64, string

// := 形式
fanOne := "666"
xiaoSheng := 666
a, b, c := true, 6.6, "fanOne"

第4步：注释与字符串基础

Go支持两种注释方式：单行注释 // 和多行注释 /* ... */。

在Go中，单引号 ' ' 用于字节（rune/int32），双引号 " " 用于UTF-8编码字符串。反引号 ` ` 用于原生字符串字面量，其中不会进行转义处理。

d := '1'      // rune (int32)
a := 'a'      // rune (int32)
b := "a"      // string
c := `'a':"b"` // string，包含单双引号字符

2. 核心数据类型详解

Go是静态强类型语言，数据类型决定了变量在内存中的大小与布局。

第1步：数值类型的选择策略

• 整型：分为有符号（int, int8...int64）和无符号（uint, uint8...uint64, byte）。注意 byte 即 uint8，常用于存储ASCII字符。rune 是 int32 别名，专门用于Unicode字符。系统默认 int 位数与架构相关（32位或64位）。
• 浮点型：仅 float32 和 float64。Go默认未指定小数点的数为 float64。需注意浮点数存在精度丢失问题。
• 复数：complex64（底層float32）和 complex128（底層float64）。可使用 complex() 创建，用 real() 和 imag() 提取分量。
• 布尔型：仅限 true 或 false，不支持整数隐式转换。

第2步：字符串处理与转换

字符串在Go中是不可变的字节序列。获取长度返回的是字节数而非字符数。索引取值返回的是对应的字节（int32/rune）。

s := "FanOne"
fmt.Println(len(s))   // 6 (字节)
fmt.Println(s[:3])    // "Fan"
fmt.Println(s[1], s[2]) // 97, 110 ('a', 'n')

字符串拼接直接使用 + 号。转换时需引入 strconv 包：

• 字符串转整数：num, err := strconv.Atoi("666")
• 整数转字符串：str := strconv.Itoa(666)

第3步：数组（Array）的局限性

Go中的数组长度固定且属于值类型。不同长度的数组被视为不同类型。

t := [...]int{1, 2, 3} // Go自动推导长度为3
fmt.Printf("%T", t)     // [3]int

由于灵活性差，实际开发中更多使用的是切片。

第4步：切片（Slice）的动态管理

切片是对数组的轻量级封装，包含指针、长度和容量。它是动态的引用类型。

创建切片的方式：

1. make 创建：
   s := make([]int, 10)（长10容10）；
   s := make([]int, 10, 15)（长10容15）。容量必须大于等于长度。
2. 字面量：
   s := []int{1, 2, 3, 4, 5}。

切片的截取规则 baseStr[low:high:max]：

• len = high - low
• cap = max - low
• 省略参数时：low默认为0，high为底层数组末端，max为底层数组总容量。

s1 := baseStr[1:3:10]
// len(s1) = 2, cap(s1) = 9

增加元素 append：

当新元素超出当前容量时，切片会自动扩容并复制数据到新的底层数组。此时原切片与新切片可能不再共享同一底层数据。

slice := []int{1, 2, 3, 4, 5}
newSlice := slice[1:3]           // len 2, cap 4
newSlice = append(newSlice, 6)   // 利用原有容量追加
// slice 也会受影响变为 [1 2 3 6 5]

第5步：Map（映射）的使用

Map是无序的键值对集合，基于Hash表实现，查询效率高。

声明与初始化：推荐使用 make 初始化，否则值为 nil。

fan := make(map[string]string)
fan["One"] = "666"
fan["Four"] = "999"

判断是否存在：通过返回值检查第二个布尔值 ok。

val, ok := fan["Two"]
if ok { fmt.Println(val) } else { fmt.Println("不存在") }

删除：使用 delete(fan, "One")。

第6步：结构体（Struct）与JSON处理

结构体是自定义的类型聚合，使用 type 和 struct 关键字定义。通过标签（Tag）可以实现与JSON的自动序列化/反序列化。

type Person struct{
    Name string `json:"name"`
    Age  int    `json:"age"`
    Sex  string `json:"sex"`
}

// JSON解析示例
data := `{"name":"FanOne","age":11,"sex":"male"}`
p := &Person{}
err := json.Unmarshal([]byte(data), p)

3. 流程控制与总结

Go摒弃了传统的 while 循环，只保留了功能更强大的 for 循环。

条件与分支

if 条件判断无需括号，但花括号必须与条件同行。switch 支持多值匹配（case 1, 2:）和默认情况，且不需要显式写 break（除非使用 fallthrough）。

循环遍历

// 传统计数循环
sum := 0
for i := 0; i < 10; i++ {
    sum += i
}

// range 遍历（适用于数组、切片、Map）
s := [3]int{1, 2, 3}
for index, val := range s {
    fmt.Println(index, val)
}

以上就是Go语言七篇入门程序结构与数据类型的详细内容，更多关于Go语言程序结构与数据类型的资料请关注本站其它相关文章！