### **1. 基础结构**
```go
package main  // 包声明（必须）
import "fmt" // 导入包

func main() { // 主函数（程序入口）
    fmt.Println("Hello, World!")
}
```

---

### **2. 变量与常量**
- **变量声明**
  ```go
  var a int = 10        // 显式类型
  var b = 20            // 类型推断
  c := 30               // 短声明（函数内使用）
  var d, e int = 1, 2   // 多变量声明
  ```
  
- **常量**
  ```go
  const Pi = 3.14
  const (
      A = 1
      B = 2
  )
  ```
- 着重强调：**开头是大写的是Public！**
---

### **3. 基本数据类型**
- **基本类型**
  ```go
  int, int8, int16, int32, int64
  uint, uint8, uint16, uint32, uint64
  float32, float64
  bool
  string
  byte (等同于 uint8)
  rune (等同于 int32, 表示 Unicode 字符)
  ```

- **复合类型**
  ```go
  var arr [3]int                   // 数组（固定长度）
  slice := []int{1, 2, 3}          // 切片（动态数组）
  m := map[string]int{"key": 1}    // 映射（字典）
  type Person struct { Name string } // 结构体
  ```

---

### **4. 控制结构**
- **条件语句**
  ```go
  if x > 0 {
      // ...
  } else if x == 0 {
      // ...
  } else {
      // ...
  }
  ```

- **循环**
  ```go
  for i := 0; i < 10; i++ { ... }   // 传统 for 循环
  for i < 10 { ... }                // 类似 while
  for index, value := range slice { ... } // 遍历切片/数组/map
  ```

- **Switch**
  ```go
  switch x {
  case 1:
      // ...
  case 2, 3:  // 多值匹配
      // ...
  default:
      // ...
  }
  ```
- 特点:不需要break！
---

### **5. 函数**
- **基本函数**
  ```go
  func add(a int, b int) int {
      return a + b
  }
  ```

- **多返回值**
  ```go
  func swap(a, b int) (int, int) {
      return b, a
  }
  ```

- **命名返回值**
  ```go
  func split(sum int) (x, y int) {
      x = sum * 4 / 9
      y = sum - x
      return // 隐式返回 x, y
  }
  ```

- **匿名函数与闭包**（即函数内套函数）
  ```go
  func() {
      fmt.Println("Anonymous function")
  }() 
  ```

---

### **6. 指针与结构体**
- **指针**
  ```go
  var p *int
  x := 10
  p = &x
  *p = 20 // 修改 x 的值
  ```
- 特点:
	- Go 的指针**不支持算术运算**，避免了内存越界和非法访问的风险，同时通过垃圾回收机制自动管理内存，**减少了内存泄漏的可能性**。
	- Go 的指针类型严格区分，空指针用 `nil` 表示，解引用空指针会触发 panic，不支持**指针算术运算和强制类型转换**。
- **结构体与方法**
  ```go
  type Circle struct {
      Radius float64
  }

  // 方法（值接收者）
  func (c Circle) Area() float64 {
      return math.Pi * c.Radius * c.Radius
  }

  // 方法（指针接收者）
  func (c *Circle) Scale(factor float64) {
      c.Radius *= factor
  }
  ```

---

### **7. 接口与错误处理**
- **接口**
  ```go
  type Shape interface {
      Area() float64
  }

  // 隐式实现接口
  func (c Circle) Area() float64 { ... }
  ```

- **错误处理**
  ```go
  func readFile() ([]byte, error) {
      data, err := os.ReadFile("file.txt")
      if err != nil {
          return nil, err
      }
      return data, nil
  }

  // 调用
  data, err := readFile()
  if err != nil {
      log.Fatal(err)
  }
  ```

- **Panic & Recover**
  ```go
  func safeCall() {
      defer func() {
          if r := recover(); r != nil {
              fmt.Println("Recovered:", r)
          }
      }()
      panic("Something went wrong!")
  }
  ```

---

### **8. 并发编程**
- **Goroutine**
  ```go
  go func() {
      fmt.Println("Running in goroutine")
  }()
  ```

- **Channel**（数据通道）
  ```go
  ch := make(chan int)
  go func() { ch <- 1 }() // 发送数据
  value := <-ch           // 接收数据
  ```

- **Select**（主要用于事件驱动）
  ```go
  select {
  case msg1 := <-ch1:
      fmt.Println(msg1)
  case msg2 := <-ch2:
      fmt.Println(msg2)
  case <-time.After(1 * time.Second):
      fmt.Println("Timeout")
  }
  ```

---

### **9. 包与模块**
- **创建模块**
  ```bash
  go mod init xx
  ```

- **导入包**
  ```go
  import (
      "fmt"
      "math/rand"
      "github.com/user/package"
  )
  ```

---

### **10. 其他特性**
- **Defer**
- `defer` 是 Go 语言中的一个关键字，用于延迟执行一个函数调用。**被 `defer` 修饰的函数调用会推迟到当前函数返回之前执行**，无论当前函数是正常返回还是由于错误（如 `panic`）提前返回。`defer` 的主要用途是确保某些操作（如资源释放、清理工作等）一定会被执行，避免遗漏。
  ```go
  func readFile() {
      file, _ := os.Open("file.txt")
      defer file.Close() // 函数返回前执行
      // ...
  }
  ```

- **JSON 处理**
  ```go
  type User struct {
      Name string `json:"name"`
      Age  int    `json:"age"`
  }
  data, _ := json.Marshal(user) //序列化
  ```

---

### **常用内置函数**
- `len()`：获取长度
- `cap()`：切片容量
- `make()`：创建切片/map/channel
- `append()`：切片追加元素
