main 文件结构与程序入口

1
2
3
4
5
6
7
8
9
10
11
12
13
// 1. 声明包名。对于可执行文件，必须是 `main`
package main

// 2. 导入其他包，例如标准库的 fmt 包，用于输入输出
import "fmt"

// 3. main 函数是程序的入口点。
// 它没有参数，也没有返回值。
func main() {
    // 4. 函数体
    // 使用 fmt 包的 Println 函数在控制台打印一行文字
    fmt.Println("Hello, World!")
}

package main: 定义了包名。main 是一个特殊的包，它告诉 Go 编译器这是一个可执行程序。

import "fmt": 导入标准库的 fmt 包，它提供了格式化输入输出的功能。导入的包必须被使用，否则编译会报错。

func main() { ... }: 定义了一个名为 main 的函数。当程序运行时，会自动从这个函数开始执行。

变量的声明和赋值

方式一：标准声明（var）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 声明一个 string 类型的变量 name，默认初始化为空字符串 ""
var name string
// 声明后赋值
name = "Alice"

// 声明的同时赋值（类型可以省略，由编译器自动推断）
var age int = 25
var height = 175 // 编译器推断 height 为 int 类型

// 同时声明多个同类型变量
var a, b, c int
// 同时声明多个不同类型变量并赋值
var (
    firstName string = "John"
    score     int    = 100
    isPassed  bool   = true
)

方式二：短变量声明（使用:=）

在函数内部，用更加简洁的:=来声明并初始化变量，其类型是由编译器自动推断的。

1
2
3
4
5
6
7
8
9
10
11
func main() {
    // 短变量声明
    name := "Bob"    // string
    age := 30        // int
    weight := 65.5   // float64

    // 同时声明多个
    x, y, z := 1, "two", true

    fmt.Println(name, age, weight, x, y, z)
}

:=不能在函数外（全局变量）使用。

常量声明（使用const）

常量的值在编译时确定，且运行期间不能修改。

1
2
3
4
5
6
const Pi = 3.14159
const Greeting = "Hello"
const (
    StatusOK = 200
    StatusNotFound = 404
)

分支结构（if/switch）

if

go的if语句不需要小括号()，但必须有花括号{}。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
score := 85

// 基本 if-else
if score >= 60 {
    fmt.Println("及格")
} else {
    fmt.Println("不及格")
}

// if 语句可以包含一个初始化语句（通常用于定义条件中使用的变量）
if grade := calculateGrade(score); grade == "A" { // grade 的作用域仅限于这个 if-else 块
    fmt.Println("优秀！")
} else if grade == "B" {
    fmt.Println("良好")
} else {
    fmt.Println("继续努力")
}
// fmt.Println(grade) // 在这里写就会报错，因为grade未定义

switch语句

go的switch默认在执行完每个case后自动break，不需要显式写出，如果需要像c一样自动继续执行，要用fallthrough关键字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
fruit := "apple"

// 最基本的用法，匹配值
switch fruit {
case "apple":
    fmt.Println("这是苹果")
case "banana", "orange": // 一个 case 可以匹配多个值
    fmt.Println("这是香蕉或橙子")
default:
    fmt.Println("未知水果")
}

// 可以没有表达式，在 case 中写条件判断（相当于替代复杂的 if-else-if 链）
score := 92
switch {
case score >= 90:
    fmt.Println("等级 A")
case score >= 80:
    fmt.Println("等级 B")
case score >= 70:
    fmt.Println("等级 C")
default:
    fmt.Println("等级 D")
}

循环结构

Go 语言中只有一种循环结构：for 循环。但它涵盖了其他语言中 for, while, do-while 的所有功能。

for用法

1
2
3
for i := 0; i < 5; i++ {
    fmt.println(i)
}

模拟while用法

1
2
3
4
5
count := 0
for count < 5 {
    fmt.println(count)
    count++
}

无限循环

1
2
3
4
5
6
// 无限循环，通常在内部配合 break 使用
for {
    fmt.Println("一直打印...")
    // break 可以跳出循环
    break // 这里立刻跳出，所以只打印一次
}

遍历集合（for-range）

for-range 结构是遍历数组、切片、字符串、map 和通道（channel）的利器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 1. 遍历数组/切片
numbers := []int{1, 2, 3, 4}
for index, value := range numbers {
    fmt.Printf("索引: %d, 值: %d\n", index, value)
}
// 如果不需要索引，可以用下划线 _ 忽略
for _, value := range numbers {
    fmt.Println(value)
}

// 2. 遍历字符串（得到的是字符的字节索引和 Unicode 码点(rune)）
str := "Go语言"
for i, r := range str {
    fmt.Printf("%d -> %c\n", i, r)
}

// 3. 遍历 map
person := map[string]string{"name": "Tom", "job": "Engineer"}
for key, value := range person {
    fmt.Printf("%s: %s\n", key, value)
}