1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

func main() {
    greeting := "你好，世界！"
    fmt.Println(greeting) // 你好，世界！

    japanese := "こんにちは"
    fmt.Println(japanese) // こんにちは

    korean := "안녕하세요"
    fmt.Println(korean) // 안녕하세요

    emoji := "🎉 Go语言太棒了！🚀"
    fmt.Println(emoji) // 🎉 Go语言太棒了！🚀
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Go语言"
    fmt.Println("字符串:", s) // 字符串: Go语言

    fmt.Println("字节长度:", len(s)) // 字节长度: 8
    fmt.Println("字符数量:", utf8.RuneCountInString(s)) // 字符数量: 4
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    text := "Hello 🌍"
    fmt.Println("字符串:", text) // 字符串: Hello 🌍

    fmt.Println("字节长度:", len(text)) // 字节长度: 10
    fmt.Println("字符数量:", utf8.RuneCountInString(text)) // 字符数量: 7
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

func main() {
    // 合法的标识符
    var name string = "合法"
    fmt.Println(name) // 合法

    // 下划线开头也合法
    var _private string = "下划线开头也合法"
    fmt.Println(_private) // 下划线开头也合法

    // 中文也行，但不推荐
    var 名字 string = "中文也行，但不推荐"
    fmt.Println(名字) // 中文也行，但不推荐
}

1
2
3

var 名字 string
var 年龄 int
var 城市 string

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

func main() {
    var user123 string = "用户123"
    fmt.Println(user123) // 用户123

    var my_var string = "下划线在中间也OK"
    fmt.Println(my_var) // 下划线在中间也OK

    var version2 string = "数字在后面完全没问题"
    fmt.Println(version2) // 数字在后面完全没问题

    var _123abc string = "下划线开头，数字在后面"
    fmt.Println(_123abc) // 下划线开头，数字在后面
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import "fmt"

func main() {
    var Name string = "张三"
    fmt.Println("Name:", Name) // Name: 张三

    var name string = "李四"
    fmt.Println("name:", name) // name: 李四

    var NAME string = "王五"
    fmt.Println("NAME:", NAME) // NAME: 王五
}

1
2
3
4
5
6
7
8

package main

func main() {
    // var 123abc string    // ❌ 编译错误：cannot start number
    // var my-name string   // ❌ 编译错误：unexpected hyphen
    // var my name string   // ❌ 编译错误：expected declaration
    // var class string     // ❌ 编译错误：cannot use keyword
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main

import "fmt"

// PublicVar 是一个导出的变量（首字母大写）
var PublicVar string = "我是公开的，谁都能用！"

// privateVar 是一个未导出的变量（首字母小写）
var privateVar string = "我是私人的，只有同包的人能看我"

func main() {
    // 在同一个包里，大王小兵都能访问
    fmt.Println("PublicVar:", PublicVar)   // PublicVar: 我是公开的，谁都能用！
    fmt.Println("privateVar:", privateVar) // privateVar: 我是私人的，只有同包的人能看我
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 文件：mypackage/package.go
package mypackage

// ExportedFunction 是一个导出的函数，其他包可以调用
func ExportedFunction() string {
    return "你好，我来自 mypackage 包！"
}

// unexportedFunction 是一个未导出的函数，只有同包能调用
func unexportedFunction() string {
    return "嘿嘿，你看不到我！"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 文件：main.go
package main

import (
    "fmt"
    "mypackage"
)

func main() {
    // 可以访问导出的函数
    fmt.Println(mypackage.ExportedFunction()) // 你好，我来自 mypackage 包！

    // 但无法访问未导出的函数——编译直接报错！
    // fmt.Println(mypackage.unexportedFunction()) // ❌ 编译错误：cannot reference unexported name
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package myserver

import "net/http"

// PublicHandler 是导出的，可以被外部包注册到路由中
func PublicHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("这是公开的处理器"))
}

// privateHandler 未导出，只能在 myserver 内部使用
func privateHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("这是内部处理器"))
}

1
2
3
4

bool byte complex64 complex128 error float32 float64
int int8 int16 int32 int64 rune string
uint uint8 uint16 uint32 uint64 uintptr
any comparable

1

iota

1

nil true false

1

append cap close complex copy delete imag len make new panic print println real recover

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import "fmt"

func main() {
    // 使用预声明的类型
    var name string = "Go语言"
    var age int = 14
    var version float64 = 1.21
    var isAwesome bool = true

    fmt.Println("语言:", name)         // 语言: Go语言
    fmt.Println("年龄:", age)          // 年龄: 14
    fmt.Println("版本:", version)      // 版本: 1.21
    fmt.Println("很酷吗:", isAwesome)  // 很酷吗: true

    // 使用预声明的函数
    slice := make([]int, 0)
    slice = append(slice, 1, 2, 3)
    fmt.Println("切片长度:", len(slice)) // 切片长度: 3
    fmt.Println("切片容量:", cap(slice)) // 切片容量: 4
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package main

import (
    "errors"
    "fmt"
)

func divide(a, b int) (int, error) {
    if b == 0 {
        // errors.New 是创建 error 值的标准方式
        return 0, errors.New("除数不能为零！你是在召唤数学恶魔吗？")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err) // 错误: 除数不能为零！你是在召唤数学恶魔吗？
    } else {
        fmt.Println("结果:", result) // 结果: 5
    }

    // 触发错误
    result, err = divide(10, 0)
    if err != nil {
        fmt.Println("错误:", err) // 错误: 除数不能为零！你是在召唤数学恶魔吗？
    }
}

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

package main

import "fmt"

// 使用 type 关键字声明一个新的类型（基于 int）
type Age int

// 使用 const 关键字声明常量
const AppName = "Go语言教程"
const Version = "1.0"

// 使用 var 关键字声明变量
var author string = "教程作者"

func main() {
    // 使用 func 关键字定义函数
    greet := func(name string) string {
        return "你好，" + name + "！欢迎学习" + AppName
    }

    var myAge Age = 25
    fmt.Println(greet("小明"))     // 你好，小明！欢迎学习Go语言教程
    fmt.Println("作者:", author)   // 作者: 教程作者
    fmt.Println("年龄类型:", myAge) // 年龄类型: 25
}

1
2

if else switch case default for range
goto break continue return

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

package main

import "fmt"

func main() {
    score := 85
    if score >= 90 {
        fmt.Println("成绩等级：优秀！你真棒！") 
    } else if score >= 70 {
        fmt.Println("成绩等级：良好。还需继续努力！") // 成绩等级：良好。还需继续努力！
    } else if score >= 60 {
        fmt.Println("成绩等级：及格。勉强过关啦～") 
    } else {
        fmt.Println("成绩等级：不及格。挂科警告！🚨") 
    }
}



**switch-case：多分支选择，就像电视节目表**


```go
package main

import "fmt"

func main() {
    day := 3
    switch day {
    case 1:
        fmt.Println("今天是星期一，Monday Blues 开始！") 
    case 2:
        fmt.Println("今天是星期二，还在适应期～") 
    case 3:
        fmt.Println("今天是星期三，小周末来了！") // 今天是星期三，小周末来了！
    case 4:
        fmt.Println("今天是星期四，明天就是周五啦！") 
    case 5:
        fmt.Println("今天是星期五，解放啦！🎉") 
    default:
        fmt.Println("这是周末还是外星日历？") 
    // 输出：今天是星期三，小周末来了！
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package main

import "fmt"

func main() {
    sum := 0
    for i := 1; i <= 5; i++ {
        sum += i
    }
    fmt.Println("1+2+3+4+5 =", sum) // 1+2+3+4+5 = 15
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package main

import "fmt"

func main() {
    fruits := []string{"苹果", "香蕉", "橙子"}
    for index, fruit := range fruits {
        fmt.Printf("第%d个水果：%s\n", index, fruit) 
    }
    // 第0个水果：苹果
    // 第1个水果：香蕉
    // 第2个水果：橙子
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

package main

import "fmt"

func main() {
    // goto：跳转到指定标签（慎用！容易写出面条代码）
    fmt.Println("1. 我是第一个")   // 1. 我是第一个
    fmt.Println("2. 我是第二个")  // 2. 我是第二个

    goto skip
    fmt.Println("3. 这一行会被跳过！") // (被 goto 跳过，不会输出)

skip:
    fmt.Println("4. 我是第四个，跳过了第三") // 4. 我是第四个，跳过了第三

    // break：跳出循环
    for i := 1; i <= 10; i++ {
        if i == 6 {
            fmt.Println("遇到6，跳出循环！") // 遇到6，跳出循环！
            break
        }
        fmt.Println("i =", i) // i = 1
                               // i = 2
                               // i = 3
                               // i = 4
                               // i = 5
                               // 遇到6，跳出循环！
    }

    // continue：跳过本次循环，继续下一次
    for j := 1; j <= 5; j++ {
        if j == 3 {
            fmt.Println("跳过3！") // 跳过3！
            continue
        }
        fmt.Println("j =", j) // j = 1
                               // j = 2
                               // 跳过3！
                               // j = 4
                               // j = 5
    }

    // fallthrough：强制执行下一个 case（Go 特有的骚操作）
    num := 2
    switch num {
    case 1:
        fmt.Println("case 1") // case 1
    case 2:
        fmt.Println("case 2（我有 fallthrough）") // case 2（我有 fallthrough）
        fallthrough
    case 3:
        fmt.Println("case 3（被 case 2 拖下来了）") // case 3（被 case 2 拖下来了）}
    // case 2（我有 fallthrough）
    // case 3（被 case 2 拖下来了）
}

1
2

go   // 启动一个协程（goroutine）
chan // 声明通道（channel）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import (
    "fmt"
    "time"
)

func fetchData(id int) {
    time.Sleep(1 * time.Second)
    fmt.Printf("任务%d完成！\n", id) // 任务?完成！\n
}

func main() {
    fmt.Println("=== 串行执行 ===") // === 串行执行 ===
    start := time.Now()

    fetchData(1) // 这个要 1 秒
    fetchData(2) // 这个也要 1 秒
    fetchData(3) // 这个也要 1 秒

    elapsed := time.Since(start)
    fmt.Printf("总耗时：%v\n", elapsed) // 总耗时：3.001s（大约3秒）
}

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

package main

import (
    "fmt"
    "time"
)

func fetchData(id int) {
    time.Sleep(1 * time.Second)
    fmt.Printf("任务%d完成！\n", id) // 任务?完成！\n
}

func main() {
    fmt.Println("=== 并发执行（使用go关键字）===") // === 并发执行（使用go关键字）===
    start := time.Now()

    go fetchData(1) // 启动任务1（不等待，立即返回）
    go fetchData(2) // 启动任务2（不等待，立即返回）
    go fetchData(3) // 启动任务3（不等待，立即返回）

    // 等待一段时间让协程完成（实际代码不应该这样写，这里只是演示）
    time.Sleep(4 * time.Second)
    elapsed := time.Since(start)
    fmt.Printf("总耗时：%v\n", elapsed) // 总耗时：约1秒（因为三个任务同时执行！）
}

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

package main

import "fmt"

func sender(ch chan<- string, msg string) {
    fmt.Printf("发送：%s\n", msg) // 发送：你好，通道！
    ch <- msg // 把消息发送到通道
}

func receiver(ch <-chan string) {
    msg := <-ch // 从通道接收消息
    fmt.Printf("接收：%s\n", msg) // 接收：?\n
}

func main() {
    // 创建一个字符串类型的通道
    message := make(chan string)

    // 启动发送和接收的协程
    go sender(message, "你好，通道！")
    go receiver(message)

    // 等待一段时间让协程完成（实际代码应该用 sync.WaitGroup）
    fmt.Scanln()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

func main() {
    a, b := 10, 3

    fmt.Println("a + b =", a+b) // a + b = 13
    fmt.Println("a - b =", a-b) // a - b = 7
    fmt.Println("a * b =", a*b) // a * b = 30
    fmt.Println("a / b =", a/b) // a / b = 3（不是3.33！）
    fmt.Println("a % b =", a%b) // a % b = 1

    // 浮点数除法就不一样了
    c, d := 10.0, 3.0
    fmt.Println("c / d =", c/d) // c / d = 3.3333333333333335
}

1
2
3
4
5
6

==  // 等于
!=  // 不等于
<   // 小于
>   // 大于
<=  // 小于等于
>=  // 大于等于

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

package main

import "fmt"

func main() {
    x, y := 5, 8

    fmt.Println("x == y:", x == y) // x == y: false
    fmt.Println("x != y:", x != y) // x != y: true
    fmt.Println("x < y:", x < y)   // x < y: true
    fmt.Println("x > y:", x > y)  // x > y: false
    fmt.Println("x <= y:", x <= y) // x <= y: true
    fmt.Println("x >= y:", x >= y) // x >= y: false

    str1, str2 := "hello", "world"
    fmt.Println("str1 == str2:", str1 == str2) // str1 == str2: false
    fmt.Println("str1 != str2:", str1 != str2) // str1 != str2: true
}

1
2
3

&&  // 逻辑与（AND），两边都为 true 才为 true
||  // 逻辑或（OR），至少一边为 true 就为 true
!   // 逻辑非（NOT），取反

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package main

import "fmt"

func main() {
    age := 25
    hasTicket := true
    hasMoney := true

    // 逻辑与：两个条件都要满足
    canWatchMovie := age >= 18 && hasTicket
    fmt.Println("能看电影（年龄够+有票）:", canWatchMovie) // 能看电影（年龄够+有票）: true

    // 逻辑或：至少满足一个
    canEnterParty := age >= 18 || hasMoney
    fmt.Println("能进派对（年龄够或有钱）:", canEnterParty) // 能进派对（年龄够或有钱）: true

    // 逻辑非：取反
    isUnderage := !canWatchMovie
    fmt.Println("未成年:", isUnderage) // 未成年: false

    // 组合使用
    canDoAnything := age >= 18 && hasTicket && hasMoney
    fmt.Println("什么都行:", canDoAnything) // 什么都行: true

    // 短路求值
    fmt.Println("---短路求值演示---") // ---短路求值演示---
    shortCircuit := false && fmt.Println("这行不会打印")
    fmt.Println("上面那行打印了吗？:", shortCircuit) // 上面那行打印了吗？: false

    shortCircuit2 := true || fmt.Println("这行也不会打印")
    fmt.Println("上面那行打印了吗？:", shortCircuit2) // 上面那行打印了吗？: true
}

1
2
3
4
5
6

&   // 按位与（AND）
|   // 按位或（OR）
^   // 按位异或（XOR）
&^  // 位清除（AND NOT）位清除常用于操作标志位，例如从一个位掩码中移除某个标志。
<<  // 左移
>>  // 右移

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package main

import "fmt"

func main() {
    a, b := 12, 10 // 二进制：a=1100，b=1010

    fmt.Printf("a = %d (二进制: %04b)\n", a, a) // a = 12 (二进制: 1100)
    fmt.Printf("b = %d (二进制: %04b)\n", b, b) // b = 10 (二进制: 1010)
    fmt.Println()

    // 按位与：都是1才为1
    fmt.Println("a & b =", a&b, "(二进制:", fmt.Sprintf("%04b", a&b), ")") // a & b = 8 (二进制: 1000 )

    // 按位或：至少一个1就为1
    fmt.Println("a | b =", a|b, "(二进制:", fmt.Sprintf("%04b", a|b), ")") // a | b = 14 (二进制: 1110 )

    // 按位异或：不一样才为1
    fmt.Println("a ^ b =", a^b, "(二进制:", fmt.Sprintf("%04b", a^b), ")") // a ^ b = 6 (二进制: 0110 )

    // 位清除：a &^ b 等价于 a & (^b)，即先对 b 按位取反，再与 a 进行按位与运算
    // 如果右操作数的某位为 1，则结果对应位为 0。
    // 如果右操作数的某位为 0，则结果对应位等于左操作数的该位。
    fmt.Println("a &^ b =", a&^b, "(二进制:", fmt.Sprintf("%04b", a&^b), ")") // a &^ b = 4 (二进制: 0100 )

    fmt.Println()

    // 左移和右移
    c := 3 // 二进制: 00000011
    fmt.Printf("c = %d (二进制: %08b)\n", c, c) // c = 3 (二进制: 00000011)

    c = c << 2 // 左移2位
    fmt.Printf("c << 2 = %d (二进制: %08b)\n", c, c) // c << 2 = 12 (二进制: 00001100)

    c = c >> 1 // 右移1位
    fmt.Printf("c >> 1 = %d (二进制: %08b)\n", c, c) // c >> 1 = 6 (二进制: 00000110)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

=   // 赋值
+=  // 加后赋值
-=  // 减后赋值
*=  // 乘后赋值
/=  // 除后赋值
%=  // 取模后赋值
&=  // 按位与后赋值
|=  // 按位或后赋值
^=  // 按位异或后赋值
<<= // 左移后赋值
>>= // 右移后赋值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package main

import "fmt"

func main() {
    x := 10

    x = 20
    fmt.Println("x =", x) // x = 20

    x += 5 // 等价于 x = x + 5
    fmt.Println("x += 5, x =", x) // x += 5, x = 25

    x -= 3 // 等价于 x = x - 3
    fmt.Println("x -= 3, x =", x) // x -= 3, x = 22

    x *= 2 // 等价于 x = x * 2
    fmt.Println("x *= 2, x =", x) // x *= 2, x = 44

    x /= 4 // 等价于 x = x / 4
    fmt.Println("x /= 4, x =", x) // x /= 4, x = 11

    x %= 3 // 等价于 x = x % 3
    fmt.Println("x %= 3, x =", x) // x %= 3, x = 2

    y := 12
    y &= 10 // 等价于 y = y & 10
    fmt.Println("y &= 10, y =", y) // y &= 10, y = 8

    y |= 3 // 等价于 y = y | 3
    fmt.Println("y |= 3, y =", y) // y |= 3, y = 11
}

1
2

&   // 取地址
*   // 指针解引用（注意和乘法的区别！）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package main

import "fmt"

func main() {
    x := 42
    fmt.Println("x的值:", x) // x的值: 42
    fmt.Println("x的地址:", &x) // x的地址: 0xc000014088（每次运行不同）

    // 指针
    ptr := &x
    fmt.Println("ptr指向的值:", *ptr) // ptr指向的值: 42
}

1

<-  // 发送或接收

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main

import "fmt"

func main() {
    ch := make(chan int, 1)

    // 发送
    ch <- 42
    fmt.Println("发送了数据到通道") // 发送了数据到通道

    // 接收
    value := <-ch
    fmt.Println("从通道接收到的值:", value) // 从通道接收到的值: 42
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 最高
*   /   %   <<  >>  &   &^

+   -   |   ^

==  !=  <   <=  >   >=

<- 

&&

// 最低
||  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import "fmt"

func main() {
    // 没有括号时，按优先级计算
    result := 2 + 3*4
    fmt.Println("2 + 3*4 =", result) // 2 + 3*4 = 14（不是20！）

    result = (2+3) * 4
    fmt.Println("(2+3)*4 =", result) // (2+3)*4 = 20

    // 逻辑运算符优先级
    a, b, c := true, false, true
    resultBool := a || b && c
    fmt.Println("a || b && c =", resultBool) // a || b && c = true
    // 因为 && 优先级高于 ||，所以等价于 a || (b && c)

    resultBool = (a || b) && c
    fmt.Println("(a || b) && c =", resultBool) // (a || b) && c = true
}

1
2
3
4
5
6
7
8

( )  // 圆括号，用于函数调用、分组表达式
{ }  // 大括号，用于代码块、复合字面量
[ ]  // 方括号，用于数组、切片、map的索引
,   // 逗号，用于分隔列表中的元素
;   // 分号，用于语句结束（通常由编译器自动添加）
:   // 冒号，用于标签、键值对、类型声明
.   // 点号，用于访问结构体字段、方法
... // 省略号，用于变长参数、切片展开

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package main

import "fmt"

func main() {
    // 圆括号：函数调用
    fmt.Println("Hello") // Hello

    // 大括号：代码块
    {
        x := 10
        fmt.Println("代码块里的x:", x) // 代码块里的x: 10
    }

    // 方括号：数组/切片索引
    arr := []int{1, 2, 3, 4, 5}
    fmt.Println("arr[2] =", arr[2]) // arr[2] = 3

    // 逗号：分隔列表
    a, b, c := 1, 2, 3
    fmt.Println(a, b, c) // 1 2 3

    // 冒号和逗号：映射/结构体字面量
    person := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }
    fmt.Println("Bob的年龄:", person["Bob"]) // Bob的年龄: 30

    // 点号：访问结构体字段
    type Point struct {
        X int
        Y int
    }
    p := Point{X: 10, Y: 20}
    fmt.Println("p.X =", p.X, "p.Y =", p.Y) // p.X = 10 p.Y = 20

    // 省略号：变长参数
    printAll := func(args ...int) {
        for _, v := range args {
            fmt.Print(v, " ") // 打印每个参数值
        }
        fmt.Println()
    }
    printAll(1, 2, 3, 4, 5) // 1 2 3 4 5

    // 省略号：切片展开
    nums := []int{10, 20, 30}
    printAll(nums...) // 10 20 30
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main

import "fmt"

func main() {
    decimal := 42
    fmt.Println("十进制 42 =", decimal) // 十进制 42 = 42

    // 十进制可以有下划线（数字分隔符）
    largeNum := 1_000_000
    fmt.Println("大数字:", largeNum) // 大数字: 1000000
}

1
2
3
4
5
6
7
8
9

package main

import "fmt"

func main() {
    octal := 0644 // 八进制的 644
    fmt.Printf("八进制 0644 = 十进制 %d\n", octal) // 八进制 0644 = 十进制 420
    fmt.Printf("十进制 %d 的八进制表示是: %o\n", octal, octal) // 十进制 420 的八进制表示是: 644
}

1
2
3
4
5
6
7
8
9

package main

import "fmt"

func main() {
    hex := 0xFF
    fmt.Printf("十六进制 0xFF = 十进制 %d\n", hex) // 十六进制 0xFF = 十进制 255
    fmt.Printf("十进制 %d 的十六进制表示是: %#X\n", hex, hex) // 十进制 255 的十六进制表示是: 0XFF
}

1
2
3
4
5
6
7
8
9

package main

import "fmt"

func main() {
    binary := 0b1010
    fmt.Printf("二进制 0b1010 = 十进制 %d\n", binary) // 二进制 0b1010 = 十进制 10
    fmt.Printf("十进制 %d 的二进制表示是: %b\n", binary, binary) // 十进制 10 的二进制表示是: 1010
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

import "fmt"

func main() {
    // 使用下划线分隔，提高可读性
    population := 1_000_000_000
    fmt.Println("人口:", population) // 人口: 1000000000

    price := 3_14.159
    fmt.Println("价格:", price) // 价格: 314.159

    // 各种进制都可以用下划线
    hexNum := 0xFF_CC_AA
    fmt.Printf("十六进制: %d\n", hexNum) // 十六进制: 16744490

    binaryNum := 0b1010_0011
    fmt.Printf("二进制: %d\n", binaryNum) // 二进制: 163
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main

import "fmt"

func main() {
    pi := 3.14159
    fmt.Println("圆周率:", pi) // 圆周率: 3.14159

    neg := -0.5
    fmt.Println("负数:", neg) // 负数: -0.5

    // 0 可以省略小数部分
    zero := 5.
    fmt.Println("5. =", zero) // 5. = 5
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

func main() {
    // 6.02e23 = 6.02 × 10^23
    avogadro := 6.02e23
    fmt.Println("阿伏伽德罗常数:", avogadro) // 阿伏伽德罗常数: 6.02e+23

    // 1.6e-19 = 1.6 × 10^-19
    electron := 1.6e-19
    fmt.Println("电子电荷:", electron) // 电子电荷: 1.6e-19

    // 大写 E 也可以
    big := 1.5E+10
    fmt.Println("大数字:", big) // 大数字: 1.5e+10
}

1
2
3
4
5
6
7
8
9

package main

import "fmt"

func main() {
    // 十六进制浮点数：0x1.fp+10 = (1 + 15/16) × 2^10
    hexFloat := 0x1.fp+10
    fmt.Println("十六进制浮点数:", hexFloat) // 十六进制浮点数: 1984
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package main

import "fmt"

func main() {
    // 复数字面量
    c1 := 1 + 2i
    fmt.Println("复数1:", c1) // 复数1: (1+2i)

    c2 := 3.14 - 1.618i
    fmt.Println("复数2:", c2) // 复数2: (3.14-1.618i)

    // 纯虚数
    pure := 5i
    fmt.Println("纯虚数:", pure) // 纯虚数: (0+5i)

    // 复数运算
    result := c1 + c2
    fmt.Println("c1 + c2 =", result) // c1 + c2 = (4.14+0.382i)

    result = c1 * c2
    fmt.Println("c1 * c2 =", result) // c1 * c2 = (6.782+2.282i)

    // 获取实部和虚部
    real := real(c1)
    imag := imag(c1)
    fmt.Printf("c1的实部: %.2f, 虚部: %.2f\n", real, imag) // c1的实部: 1.00, 虚部: 2.00
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main

import "fmt"

func main() {
    letter := 'A'
    digit := '7'
    symbol := '#'

    fmt.Printf("letter: %c (Unicode: U+%04X, ASCII: %d)\n", letter, letter, letter) // letter: A (Unicode: U+0041, ASCII: 65)

    fmt.Printf("digit: %c (Unicode: U+%04X, ASCII: %d)\n", digit, digit, digit) // digit: 7 (Unicode: U+0037, ASCII: 55)

    fmt.Printf("symbol: %c (Unicode: U+%04X, ASCII: %d)\n", symbol, symbol, symbol) // symbol: # (Unicode: U+0023, ASCII: 35)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

func main() {
    // 中文符文
    chinese := '中'
    fmt.Printf("中文 '中' : %c (Unicode: U+%04X)\n", chinese, chinese) // 中文 '中' : 中 (Unicode: U+4E2D)

    // 日文
    japanese := '日'
    fmt.Printf("日文 '日': %c (Unicode: U+%04X)\n", japanese, japanese) // 日文 '日': 日 (Unicode: U+65E5)

    // emoji
    emoji := '🎉'
    fmt.Printf("emoji '🎉': %c (Unicode: U+%04X)\n", emoji, emoji) // emoji '🎉': 🎉 (Unicode: U+1F389)
}

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

package main

import "fmt"

func main() {
    // 常见的转义序列
    fmt.Println("换行符:\n第一行\n第二行") 
    // 换行符:
    // 第一行
    // 第二行

    fmt.Println("制表符:\t左\t右\t中间") // 制表符:	左	右	中间


    fmt.Println("反斜杠:\\") // 反斜杠:\

    fmt.Println("双引号:\"") // 双引号:"
 

    fmt.Println("单引号:'") // 单引号:'

    fmt.Println("Unicode字符:\u4e2d\u6587") // Unicode字符:中文

    fmt.Println("警报声:\a") // 警报声:      需要编译成可执行文件再运行才会出现响一声
}

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

package main

import "fmt"

func main() {
    // 普通字符串
    greeting := "Hello, World!"
    fmt.Println(greeting) // Hello, World!

    // 包含转义序列
    path := "C:\\Program Files\\Go"
    fmt.Println("路径:", path) // 路径: C:\Program Files\Go

    // 包含换行
    multi := "第一行\n第二行"
    fmt.Println("多行:") // 多行:

    fmt.Println(multi) 
    // 第一行
	// 第二行
    fmt.Println(multi)
    // 第一行
	// 第二行
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

import "fmt"

func main() {
    // 反引号字符串：所见即所得
    raw := `第一行\n第二行\t制表符`
    fmt.Println("原始字符串:") // 原始字符串:
    fmt.Println("原始字符串:") // 原始字符串:
    fmt.Println(raw) // 第一行\n第二行\t制表符

    // 适合写正则表达式
    regex := `\+?\[0-9\]+`
    fmt.Println("正则:", regex) // 正则: +?\[0-9\]+

    // 适合写 SQL
    sql := `SELECT * FROM users WHERE name = '张三'`
    fmt.Println("SQL:", sql) // SQL: SELECT * FROM users WHERE name = '张三'
}

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

package main

import "fmt"

func main() {
    // 常见的转义
    fmt.Println("Hello\tWorld") // Hello	World
    fmt.Println("Line1\nLine2") // Line1
                                // Line2

    // 八进制和十六进制转义
    fmt.Println("\101\102\103") // ABC（八进制转义）
    fmt.Println("\x41\x42\x43") // ABC（十六进制转义）

    // Unicode 转义
    fmt.Println("\u4e2d\u6587") // 中文
    fmt.Println("\U00004e2d\U00006587") // 中文
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import "fmt"

func main() {
    // 这是单行注释，只会到这里结束
    fmt.Println("Hello, World!") // 行尾也可以有注释

    // 注释可以写很多行
    // 第二行
    // 第三行
    x := 42 // 这里的注释解释 x 是干什么的
    fmt.Println("x =", x) // x = 42
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import "fmt"

func main() {
    /* 这是多行注释
       可以写很多很多内容
       直到遇到结束符号 */
    fmt.Println("多行注释演示") // 多行注释演示

    /* 也可以只注释掉一行代码
    fmt.Println("这行被注释掉了") // (这行在注释块中，不会执行)
    */

    /*
    整段代码都可以注释掉：
    for i := 0; i < 10; i++ {
    fmt.Println(i) // (在注释块中，不会执行)
    }
    */
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Package geometry 提供平面几何的基本计算功能
//
// 支持的功能包括：
//   - 矩形面积和周长计算
//   - 圆形面积和周长计算
//   - 三角形面积计算（海伦公式）
//
// 使用示例：
//
//  rect := geometry.NewRectangle(10, 5)
//  fmt.Println("矩形面积:", rect.Area())
package geometry

// Rectangle 表示一个矩形
type Rectangle struct {
    Width  float64 // 宽度
    Height float64 // 高度
}

// NewRectangle 创建一个新的矩形
//
// width: 矩形的宽度（必须大于0）
// height: 矩形的高度（必须大于0）
func NewRectangle(width, height float64) *Rectangle {
    return &Rectangle{Width: width, Height: height}
}

// Area 计算矩形的面积
//
// 返回值：矩形的面积（Width × Height）
func (r *Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Perimeter 计算矩形的周长
//
// 返回值：矩形的周长（2 × (Width + Height)）
func (r *Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main

import (
    "fmt"
    "geometry"
)

func main() {
    rect := geometry.NewRectangle(10, 5)
    fmt.Println("矩形面积:", rect.Area())     // 矩形面积: 50
    fmt.Println("矩形周长:", rect.Perimeter()) // 矩形周长: 30
}