update

golang-learn/01-env_hello_world/go.mod

@@ -1,3 +0,0 @@
-module env_hello_world
-
-go 1.22.2

golang-learn/02-package_import/go.mod

@@ -0,0 +1,3 @@
+module package_import
+
+go 1.22.2

golang-learn/02-package_import/main.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"package_import/quote"
+)
+
+func main() {
+	quote.PrintQuote()
+}

golang-learn/02-package_import/quote/quote.go

@@ -0,0 +1,9 @@
+// quote/quote.go
+package quote
+
+import "fmt"
+
+// PrintQuote 是一个导出函数，打印一句名言
+func PrintQuote() {
+	fmt.Println("The only way to do great work is to love what you do. — Steve Jobs")
+}

golang-learn/03-visibility_rules/go.mod

@@ -0,0 +1,3 @@
+module visibility_rules
+
+go 1.22.2

golang-learn/03-visibility_rules/main.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"fmt"
+	"visibility_rules/utils"
+)
+
+func main() {
+	fmt.Println(utils.Public)  // ✅ 合法，可以访问
+	fmt.Println(utils.private) // ❌ 非法，不能访问
+}

golang-learn/03-visibility_rules/utils/visibility_rules.go

@@ -0,0 +1,5 @@
+// utils/visibility_rules.go
+package utils
+
+var Public = 1  // 首字母大写，可以被其他包访问
+var private = 2 // 首字母小写，不能被其他包访问

golang-learn/04-variables_var/main.go

@@ -0,0 +1,28 @@
+package main
+
+import "fmt"
+
+func main() {
+	var i int
+	var f int64
+	var b bool
+	var s string
+	var r rune
+	var arr [3]int       // 数组零值: 每个元素都是 0
+	var slice []int      // 切片零值: nil
+	var m map[string]int // 映射零值: nil
+	var p *int           // 指针零值: nil
+
+	fmt.Println("int      :", i)
+	fmt.Println("float64  :", f)
+	fmt.Println("bool     :", b)
+	fmt.Println("string   :", s)
+	fmt.Println("rune     :", r)
+	fmt.Println("array    :", arr)
+	fmt.Printf("slice    : %v (== nil ? %v)\n", slice, slice == nil)
+	fmt.Printf("map      : %v (== nil ? %v)\n", m, m == nil)
+	fmt.Printf("pointer  : %v (== nil ? %v)\n", p, p == nil)
+
+	var x, y, z float64 = 1.1, 2.2, 3.3
+	fmt.Println("x:", x, "y:", y, "z:", z)
+}

golang-learn/05-short_declaration/go.mod

@@ -0,0 +1,3 @@
+module short_declaration
+
+go 1.22.2

golang-learn/05-short_declaration/short_declaration.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func main() {
+	name := "jack"
+	age := 666
+	ratio := 3.14
+	ok := true
+	nextYear := age + 1        // 运算结果同样可用 :=
+	name, city := "jack", "gz" // 多变量同时短声明（重声明 name 合法）
+	_, _ = name, city          // 避免 city 未使用报错
+
+	fmt.Println(name, age, ratio, ok, nextYear)
+}

golang-learn/06-constants_iota/constants_iota.go

@@ -0,0 +1,71 @@
+// iota_cheatsheet.go
+package main
+
+import "fmt"
+
+/*
+	-------------------------------------------------
+	  1) 顺序枚举（最常用）
+	     Sunday=0, Monday=1, ..., Saturday=6
+
+-------------------------------------------------
+*/
+const (
+	Sunday = iota // 0
+	Monday        // 1
+	Tuesday
+	Wednesday
+	Thursday
+	Friday
+	Saturday
+)
+
+/*
+	-------------------------------------------------
+	  2) 位掩码（flags）
+	     每个常量占 1 个二进制位，可用于权限/选项
+
+-------------------------------------------------
+*/
+const (
+	Read  = 1 << iota // 0b0001
+	Write             // 0b0010
+	Exec              // 0b0100
+)
+
+/*
+	-------------------------------------------------
+	  3) 自定义步长或公式
+	     生成 1KB, 1MB, 1GB ... 的精确字节数
+
+-------------------------------------------------
+*/
+const (
+	_  = iota             // 0 丢掉
+	KB = 1 << (10 * iota) // 1 << 10  = 1024
+	MB                    // 1 << 20  = 1048576
+	GB                    // 1 << 30  = 1073741824
+)
+
+/*
+	-------------------------------------------------
+	  4) 跳号 + 中途改公式
+	     演示跳过某个值、后续再换算法
+
+-------------------------------------------------
+*/
+const (
+	A = iota      // 0
+	B             // 1
+	_             // 2 被跳过
+	C             // 3
+	D = iota + 10 // 4+10 = 14
+	E             // 5+10 = 15
+)
+
+func main() {
+	fmt.Println("Weekday:", Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)
+	fmt.Println("Flags  :", Read, Write, Exec)
+	fmt.Println("Storage:", KB, MB, GB)
+	fmt.Println("Misc   :", A, B, C, D, E)
+}

golang-learn/06-constants_iota/go.mod

@@ -0,0 +1,3 @@
+module constants_iota
+
+go 1.22.2

golang-learn/07-basic_data_types/basic_data_types.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	var c complex128 = 1 + 2i
+
+	// 打印实部 real(c) 和虚部 imag(c)
+	fmt.Printf("real = %.1f\n", real(c))
+	fmt.Printf("imag = %.1f\n", imag(c))
+}

golang-learn/07-basic_data_types/go.mod

@@ -0,0 +1,3 @@
+module basic_data_types
+
+go 1.22.2

golang-learn/08-string_operations/go.mod

@@ -0,0 +1,3 @@
+module string_operations
+
+go 1.22.2

golang-learn/08-string_operations/string_operations.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+func main() {
+	s := "hello"
+
+	// 1) 打印原始长度 & []rune 形式
+	fmt.Println("len(s)     =", len(s))
+	fmt.Println("[]rune(s)  =", []rune(s))
+
+	// 2) 逆序输出：转成 []rune 后倒序拼接
+	runes := []rune(s) // 正确支持 Unicode
+	n := len(runes)
+	reversed := make([]rune, n)
+
+	for i, r := range runes { // for range 遍历每个字符
+		reversed[n-1-i] = r
+	}
+
+	fmt.Println("reversed   =", string(reversed))
+}

golang-learn/09-arrays/arrays.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+// sumArray 接收一个长度为 3 的 int 数组（值类型），返回元素之和
+func sumArray(a [3]int) int {
+	sum := 0
+	for _, v := range a {
+		sum += v
+	}
+	return sum
+}
+
+func main() {
+	var a [3]int = [3]int{1, 2, 3}
+	fmt.Println("sum =", sumArray(a))
+}
+
+// 运行结果：
+// sum = 6

golang-learn/09-arrays/go.mod

@@ -0,0 +1,3 @@
+module arrays
+
+go 1.22.2

golang-learn/10-slices/slices.go

@@ -6,6 +6,7 @@ import "fmt"
 // 如果 index 越界，原样返回，不做删除
 func remove(s []int, index int) []int {
 	if index < 0 || index >= len(s) {
+		fmt.Println("数组越界")
 		return s // 越界保护
 	}
 	// 把 index+1 之后的元素整体前移 1 位，再截掉最后一个

golang-learn/11-slice_internals/go.mod

@@ -0,0 +1,3 @@
+module slice_internals
+
+go 1.22.2

golang-learn/11-slice_internals/slice_internals.go

@@ -0,0 +1,31 @@
+package main
+
+import "fmt"
+
+func main() {
+	// 1) 创建一个长度、容量都为 3 的切片
+	s := make([]int, 3, 3)
+	fmt.Printf("初始: len=%d  cap=%d  ptr=%p %p\n", len(s), cap(s), s, &s)
+
+	// 2) 再追加 3 个元素，刚好填满底层数组
+	s = append(s, 4, 5, 6)
+	fmt.Printf("填满: len=%d  cap=%d  ptr=%p\n", len(s), cap(s), s)
+
+	// 3) 再追加 1 个元素，触发扩容
+	//    在 Go1.18+ 的扩容策略中，当元素数量 ≤ 256 时，容量直接翻倍
+	s = append(s, 7)
+	fmt.Printf("扩容: len=%d  cap=%d  ptr=%p\n", len(s), cap(s), s)
+
+	// 4) 继续追加，观察下一次扩容
+	for i := 8; i <= 20; i++ {
+		s = append(s, i)
+	}
+	fmt.Printf("再扩: len=%d  cap=%d  ptr=%p\n", len(s), cap(s), s)
+
+	// 5) 共享底层数组示例
+	a := []int{10, 20, 30, 40}
+	b := a[1:3] // b 与 a 共享底层数组
+	fmt.Printf("共享前 a=%v  b=%v\n", a, b)
+	b[0] = 99
+	fmt.Printf("共享后 a=%v  b=%v  (修改 b[0] 影响 a)\n", a, b)
+}

golang-learn/12-maps/go.mod

@@ -0,0 +1,3 @@
+module maps
+
+go 1.22.2

golang-learn/12-maps/maps.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	// 1) 统计每个单词出现次数
+	counts := make(map[string]int)
+
+	// 2) 直接内置 3 行文本，不再从标准输入读
+	lines := []string{
+		"go is fun",
+		"go go go",
+		"python is fun too",
+	}
+
+	// 3) 逐行逐词统计
+	for _, line := range lines {
+		for _, word := range strings.Fields(line) {
+			counts[word]++
+		}
+	}
+
+	// 4) 打印单词 → 次数
+	for w, c := range counts {
+		fmt.Printf("%q 出现了 %d 次\n", w, c)
+	}
+
+	// 5) 再建一个 map：单词 → 出现过的行号
+	index := make(map[string][]int)
+	for lineno, line := range lines {
+		for _, word := range strings.Fields(line) {
+			index[word] = append(index[word], lineno+1)
+		}
+	}
+	fmt.Println(index)
+}

golang-learn/13-structs/go.mod

@@ -0,0 +1,3 @@
+module structs
+
+go 1.22.2

golang-learn/13-structs/structs.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+// 1) 定义结构体
+type Point struct {
+	X, Y float64
+}
+
+//  2. 给 Point 添加 Distance 方法
+//     p.Distance(q) 算 p 到 q 的欧氏距离
+func (p Point) Distance(q Point) float64 {
+	dx := p.X - q.X
+	dy := p.Y - q.Y
+	return math.Sqrt(dx*dx + dy*dy)
+}
+
+func main() {
+	// 3) 用字面量创建两个点
+	a := Point{X: 3, Y: 4}
+	b := Point{X: 0, Y: 0}
+
+	// 4) 调用方法
+	fmt.Printf("a=%v, b=%v, 距离=%.2f\n", a, b, a.Distance(b)) // 期望 5.00
+}

golang-learn/14-pointers/go.mod

@@ -0,0 +1,3 @@
+module pointers
+
+go 1.22.2

golang-learn/14-pointers/pointers.go

@@ -0,0 +1,28 @@
+package main
+
+import "fmt"
+
+/*
+swap(a, b *int) 这个函数可以把两个整数的值互换，但它需要这两个整数的“地址”（指针），这样它才能直接修改原始变量的值。
+你可以想象x和y是两个盒子，分别装着42和99。swap函数要交换它们盒子里的东西，但只能拿到盒子的“门牌号”（地址），这样它才能真的改动盒子里的东西。
+在swap函数里，先把a指向的数字（就是x的值）存进一个临时变量tmp。
+然后把b指向的数字（y的值）放到a指向的地方（x的位置）。
+最后把tmp（原来x的值）放到b指向的地方（y的位置）。至此，x和y的值就交换了。
+main函数里，先打印交换前x和y的值，然后通过&x、&y把x和y的地址传给swap，交换成功后再打印一次，看到值已经互换。
+*/
+
+// 交换函数：传入两个int类型的指针参数
+func swap(a, b *int) {
+	// 用临时变量tmp先保存a指向的值
+	tmp := *a // *a表示a指向的地址中存储的值
+	*a = *b   // 把b指向的值赋给a指向的内存单元
+	*b = tmp  // 把刚才保存的a的值赋给b指向的内存单元
+}
+
+func main() {
+	x, y := 42, 99 // 定义两个整型变量x和y
+	fmt.Printf("交换前 x=%d, y=%d\n", x, y)
+
+	swap(&x, &y) // 传入变量x、y的地址，实现交换
+	fmt.Printf("交换后 x=%d, y=%d\n", x, y)
+}

golang-learn/Readme.md

@@ -8,7 +8,7 @@
 文件名: package_import
 概念：package 声明规则、import 语法、别名、点导入、空白导入
 代码：package main; import ("fmt"; "math/rand"); func main(){ fmt.Println(rand.Int()) }
-练习：新建一个 quote 包，导出一个函数打印一句名言。
+练习：go mod init myproject 新建一个 quote 包，导出一个函数打印一句名言。
 
 03.可见性规则
 文件名: visibility_rules