```

docs(day01): 添加运算符和变量作用域文档

- 新增运算符文档，详细介绍Go语言的算术、关系、逻辑、位、赋值等运算符
- 添加变量作用域文档，涵盖局部变量、全局变量、作用域嵌套和可见性规则
- 补充相关代码示例和实践案例
- 更新README目录结构，添加新章节链接
```

day01/README.md

@@ -21,4 +21,4 @@
 + [基础语法](./syntax/README.md)
 + [基础类型](./base_type/README.md)
 + [变量作用域](./scope/README.md)
-+ 运算符
++ [运算符](./operate/README.md)

day01/operate/README.md

@@ -0,0 +1,166 @@
+# 语言运算符
+
+Go 语言内置的运算符有:
+
++ 算术运算符
++ 关系运算符
++ 逻辑运算符
++ 位运算符
++ 赋值运算符
++ 其他运算符
+
+## 算术运算符
+
++ \+ 加法运算
++ \- 减法运算
++ \* 乘法运算
++ / 除法运算
++ % 求余运算
+
+由于Go是强类型语言, 因此要求参与运算的对象类型必须相同，比如下面就是不可以的
+
+```go
+// var (
+//     a = 10
+//     b = 20
+// )
+var a, b uint = 10, 20
+
+a + b // 30
+a - b // 18446744073709551606
+```
+
+```go
+a * b // 200
+a / b // 0
+a % b // 10
+```
+
+浮点型的运算
+
+```go
+var a, b float64 = 10, 20
+a + b // 30
+a - b // -10
+a * b // 200
+a / b // 0.5
+```
+
+## 关系运算符
+
+用于对2个值进行比较的运算符, 比较结果为真(True) 或者 假(False)
+
++ == 判断两个值是否相等
++ != 判断两个值是否不相等
++ \> 左边值是否大于右边值
++ \>= 左边值是否大于等于右边值
++ <  左边值是否小于右边值
++ <= 左边值是否小于等于右边值
+
+```go
+a, b := 10, 20
+a > b
+a >= b
+a < b
+```
+
+常见的用法是用于条件语句: 我们进行一个a b 的简单排序
+
+```go
+a, b := 20, 10
+if a > b {
+    a, b = b, a
+}
+```
+
+## 逻辑运算符
+
+用于对布尔表达式进行逻辑计算, 有如下3种:
+
++ && 与(ADD), 如果两边的操作数都是 True，则条件 True，否则为 False。
++ || 或(OR), 如果两边的操作数有一个 True，则条件 True，否则为 False
++ ! 非(NOT), 如果条件为 True，则逻辑 NOT 条件 False，否则为 True
+
+```go
+age := 90
+gender := "male"
+
+if age > 80 && gender == "male" {
+    fmt.Println("old boy")
+} else {
+    fmt.Println("too young,too simple")
+}
+```
+
+## 位运算符
+
+位运算符对整数在内存中的二进制位进行操作, 运算符有:
+
++ & 按位与, 参与运算的两数各对应的二进位相与  当两对应的二进位, 都为1时, 结果为1
++ | 按位或, 参与运算的两数各对应的二进位相或, 当两对应的二进位, 有1方为1，结果为1
++ ^ 按位异或, 参与运算的两数各对应的二进位相异或, 当两对应的二进位相异时，结果为1
++ 左移 高位丢弃，低位补0, 左移n位就是乘以2的n次方
++ 右移 高位丢弃，低位补0, 移n位就是除以2的n次方
+
+```go
+var (
+    a uint = 60 // 0011 1100  2^5 + 2^4 + 2^3 + 2^2
+    b uint = 85 // 0101 0101  2^6 + 2^4 + 2^2 + 2^0
+)
+fmt.Println("a & b = %d", a&b)   // 0001 0100     2^4 + 2^2
+fmt.Println("a | b = %d", a|b)   // 0111 1101     2^6 + 2^5 + 2^4 + 2^3 + 2^2 + 2^0
+fmt.Println("a ^ b = %d", a^b)   // 0110 1001     2^6 + 2^5 + 2^3 + 2^0
+fmt.Println("a >> 2 = %d", a>>2) // 0000 1111     15
+fmt.Println("a << 2 = %d", a<<2) // 1111 0000     240
+```
+
+常用与协议定义, 比如一个byte 8位
+
+```go
+0000 0000
+       --
+       标识性别: 00: 未知， 01: 男 10: 女 11: 保留
+    --
+    保留
+----
+标识城市: 0000: 未知, 0001: A, 0010: B
+```
+
+byte 0x17 表示什么?  (十进制: 23, 二进制: 0001 0111)
+
+## 赋值运算符
+
+最基本用法:
+
++ = 简单的赋值运算符，将一个表达式的值赋给一个左值
+
+```go
+a := 10 // 把10赋值给变量a
+```
+
++ += 相加后再赋值  
++ -= 相减后再赋值
++ *= 相乘后再赋值
++ /= 相除后再赋值
++ %= 求余后再赋值
++ <<= 左移后赋值
++ \>\>= 右移后赋值
++ &= 按位与后赋值
++ |= 按位异或后赋值
++ ^= 按位或后赋值
+
+```go
+a := 10
+a += 5 // a = a + 5
+```
+
+## 其他运算符
+
++ & 返回变量存储地址
++ \* 取出地址对应的值
+
+```go
+a := 10
+b := &a
+*b += 5
+```

day01/operate/main.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := 10.0
+	b := 20
+	// + 算数运算符
+	c := float64(a) / float64(b)
+	fmt.Println("a / b = ", c)
+
+	// 相同类型
+	c = 10 / 0.1
+}

day01/scope/README.md

@@ -1,2 +1,81 @@
 # 变量作用域
 
+作用域: 这个变量在哪个范围内可以被访问到
+
++ 基础作用域: 块作用域, {}, 在块作用域下的变量都是局部变量
+
+## 局部变量
+
+### 父作用域 不能访问子作用域的变量
+
+```go
+{
+    {
+        var a string
+        a = "local var"
+        fmt.Println(a)
+    }
+    // fmt.Println(a)
+}
+
+```
+
+### 子作用域可以访问父作用域的变量
+
+```go
+{
+    var a string
+    a = "parent scope"
+    {
+        fmt.Println(a)
+    }
+}
+```
+
+### 变量值覆盖
+
+子作用域的优先级是高于父作用域的优先级的, 因此子作用域可以覆盖父作用域的变量的值, 但是同一个变量不能声明2次
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    var a = "parent"
+    fmt.Println("outer:", a) // parent
+    {
+        a := "child" // 子作用域声明了同名新变量（遮蔽外层 a）
+        fmt.Println("inner:", a) // child
+    }
+    fmt.Println("outer again:", a) // 仍为 parent
+}
+```
+
+## 全局变量
+
+在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用, 全局变量相当于所有函数的父级变量, 所有函数都能访问
+
+```go
+var (
+    a = "global parent scope var"
+)
+
+func main() {
+    fmt.Println(a)
+}
+```
+
+## 导出与不可导出（可见性）
+
+约定：标识符以大写字母开头表示可导出（可被其他包访问），以小写字母开头表示仅包内可见。
+
+```go
+// 包内文件 a.go
+package demo
+
+var Exported = "可导出"
+var internal = "包内可见"
+
+// 其他包：import demo 后只能访问 demo.Exported
+```

day01/scope/demo/go.mod

@@ -0,0 +1,3 @@
+module demo
+
+go 1.25.5

day01/scope/demo/main.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"demo/pkg1"
+	"fmt"
+)
+
+func main() {
+	println("Hello, World!")
+
+	fmt.Println(pkg1.GetVar3())
+
+	// 函数是一种类型
+	// fn := pkg1.GetVar3
+	// fn()
+}

day01/scope/demo/pkg1/vars.go

@@ -0,0 +1,14 @@
+package pkg1
+
+// 导出变量 首字母大写（public）
+var (
+	Var1 = "This is Var1"
+	Var2 = "This is Var2"
+
+	// 未导出变量 首字母小写(private)
+	var3 = "This is var3" // unexported variable
+)
+
+func GetVar3() string {
+	return var3
+}

day01/scope/main.go

@@ -0,0 +1,31 @@
+package main
+
+import "fmt"
+
+var (
+	// main 包里面的变量
+	age = 18
+)
+
+func main() {
+	var a = "parent"
+	fmt.Println("outer:", a) // parent
+	{
+		a = "child"              // 子作用域声明了同名新变量（遮蔽外层 a）
+		fmt.Println("inner:", a) // child
+	}
+	fmt.Println("outer again:", a) // 仍为 child
+
+	// 局部变量
+	var b = "parent"
+	fmt.Println("outer:", b) // parent
+	{
+		// var b = "child"
+		// 新的局部变量b
+		b := "child"             // 子作用域声明了同名新变量（遮蔽外层 a）
+		fmt.Println("inner:", b) // child
+	}
+	fmt.Println("outer again:", b) // 仍为 parent
+
+	fmt.Println(age)
+}