Go语言中各种常见写法

Go创建channel的所有常见写法

// 1. 无缓冲 channel，基本类型 int
ch1 := make(chan int)

// 2. 带缓冲 channel，基本类型 int，缓冲大小 10
ch2 := make(chan int, 10)

// 3. 无缓冲 channel，元素类型 string
ch3 := make(chan string)

// 4. 带缓冲 channel，元素类型 string，缓冲大小 5
ch4 := make(chan string, 5)

// 5. 无缓冲 channel，元素类型 struct
type Point struct { X, Y int }
ch5 := make(chan Point)

// 6. 带缓冲 channel，元素类型指针，缓冲大小 3
ch6 := make(chan *Point, 3)

// 7. 无缓冲 channel，元素类型 interface{}
ch7 := make(chan interface{})

// 8. 带缓冲 channel，元素类型函数类型
ch8 := make(chan func(int) int, 2)

// 9. 声明 channel 变量，不初始化
var ch9 chan int

// 10. 初始化后赋值
ch9 = make(chan int)

// 11. 只读 channel
var chReadOnly <-chan int = make(chan int)

// 12. 只写 channel
var chWriteOnly chan<- int = make(chan int)

Go数组的所有常见写法

// 1. 声明一个长度为3的int数组（元素默认0）
var arr1 [3]int

// 2. 声明并初始化数组，长度3
arr2 := [3]int{1, 2, 3}

// 3. 编译器推断长度
arr3 := [...]int{4, 5, 6, 7}

// 4. 部分初始化，未初始化元素为零值
arr4 := [5]int{1, 2}

// 5. 使用索引指定初始化
arr5 := [5]int{0: 10, 3: 20}  // arr5 = [10 0 0 20 0]

// 6. 字符串数组
arr6 := [3]string{"a", "b", "c"}

// 7. 多维数组，2x3的int数组
arr7 := [2][3]int{{1, 2, 3}, {4, 5, 6}}

// 8. 零长度数组
var arr8 [0]int

// 9. 声明数组变量，不初始化（默认值零值）
var arr9 [4]float64

// 10. 指定类型数组指针
var p *[3]int
p = &arr2

// 11. 数组切片转换（注意，Go没有数组切片，但数组可以转换成切片）
slice := arr2[:]  // 转换为切片

// 12. 数组元素为结构体
type Point struct{X, Y int}
arr10 := [2]Point{{1, 2}, {3, 4}}

// 13. 使用new创建数组指针
p2 := new([5]int)  // p2是*[5]int，元素全为0

// 14. 使用var声明多维数组
var arr11 [3][2]string

Go切片所有常见写法

// 1. 声明一个空切片（nil切片）
var s1 []int

// 2. 声明并初始化空切片（长度0）
s2 := []int{}

// 3. 使用字面量初始化切片
s3 := []int{1, 2, 3, 4}

// 4. 使用make创建切片，长度和容量都为5，元素为零值
s4 := make([]int, 5)

// 5. 使用make创建切片，长度3，容量5（底层数组长度5，但初始有效长度3）
s5 := make([]int, 3, 5)

// 6. 从数组切片，创建切片
arr := [5]int{10, 20, 30, 40, 50}
s6 := arr[1:4]  // 包含arr[1],arr[2],arr[3]

// 7. 切片零值为nil，可通过判断len==0或者s==nil判断空切片
var s7 []string
fmt.Println(s7 == nil)  // true

// 8. 声明切片类型变量，但未初始化，默认是nil
var s8 []float64

// 9. 多维切片（切片的切片）
s9 := [][]int{{1, 2}, {3, 4, 5}}

// 10. 追加元素到切片
s10 := []int{1, 2}
s10 = append(s10, 3, 4)

// 11. 切片容量扩容示例
s11 := make([]int, 0, 2)
s11 = append(s11, 1, 2, 3)  // 自动扩容

// 12. 直接声明切片类型变量（不初始化）
var s12 []struct{ X, Y int }

// 13. 使用切片表达式切片切片
s13 := s3[1:3]

// 14. 指定切片长度和容量（底层数组长度）
s14 := make([]int, 3, 10)

// 15. 使用切片作为函数参数传递
func f(slice []int) { ... }

// 16. 复制切片数据
dst := make([]int, len(s3))
copy(dst, s3)

Go map所有常见写法

// 1. 声明空 map，未初始化（为 nil）
var m1 map[string]int

// 2. 初始化空 map（容量可选）
m2 := make(map[string]int)
m3 := make(map[string]int, 10) // 预留容量 10

// 3. 字面量初始化 map
m4 := map[string]int{
    "a": 1,
    "b": 2,
    "c": 3,
}

// 4. 声明 map 变量并初始化
var m5 map[int]string = make(map[int]string)

// 5. map key 是结构体
type Point struct{ X, Y int }
m6 := make(map[Point]string)
m6[Point{1, 2}] = "A"

// 6. map key 是指针类型
m7 := make(map[*int]string)

// 7. map value 是切片
m8 := make(map[string][]int)
m8["scores"] = []int{90, 85, 88}

// 8. map value 是结构体
m9 := make(map[string]Point)
m9["p1"] = Point{3, 4}

// 9. map value 是接口类型
var m10 = make(map[string]interface{})
m10["num"] = 100
m10["str"] = "hello"

// 10. 声明只读 map 变量（只读语义，非语言层面，常用 const 代替）
// Go 没有内建只读 map 类型，需自行封装

// 11. 使用 make 并指定容量（性能优化）
m11 := make(map[int]int, 1000)

// 12. map 嵌套 map
m12 := make(map[string]map[string]int)
m12["outer"] = make(map[string]int)
m12["outer"]["inner"] = 42

Go 结构体所有常见写法

// 1. 声明一个空结构体类型
type Person struct {
    Name string
    Age  int
}

// 2. 创建结构体变量，字段默认零值
var p1 Person

// 3. 字面量初始化（字段顺序赋值）
p2 := Person{"Alice", 30}

// 4. 字面量初始化（字段名赋值，更安全）
p3 := Person{
    Name: "Bob",
    Age:  25,
}

// 5. 指针类型结构体变量
p4 := &Person{
    Name: "Charlie",
    Age:  40,
}

// 6. 匿名结构体声明并初始化
p5 := struct {
    Name string
    Age  int
}{
    Name: "Diana",
    Age:  22,
}

// 7. 嵌套结构体
type Address struct {
    City, State string
}

type Employee struct {
    Person
    Address
    Salary float64
}

emp := Employee{
    Person:  Person{Name: "Eve", Age: 35},
    Address: Address{City: "New York", State: "NY"},
    Salary:  75000,
}

// 8. 结构体指针访问字段
p := &Person{Name: "Frank", Age: 28}
fmt.Println(p.Name) // 自动解引用

// 9. 结构体零值比较（结构体是值类型，可直接比较）
p6 := Person{}
p7 := Person{}
fmt.Println(p6 == p7) // true

// 10. 带标签的结构体字段（用于 JSON、ORM 等）
type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email,omitempty"`
}

// 11. 匿名字段（嵌入式字段）
type Animal struct {
    Name string
}

type Dog struct {
    Animal
    Breed string
}

d := Dog{Animal: Animal{Name: "Buddy"}, Breed: "Beagle"}

// 12. 结构体切片
var people []Person
people = append(people, Person{Name: "Grace", Age: 27})

// 13. 结构体数组
var arr [3]Person

// 14. 结构体作为函数参数和返回值
func printPerson(p Person) {
    fmt.Println(p.Name, p.Age)
}

func getPerson() Person {
    return Person{Name: "Hank", Age: 31}
}

// 15. 结构体方法（绑定方法）
func (p Person) Greet() {
    fmt.Println("Hello,", p.Name)
}

// 16. 指针接收者方法，允许修改结构体内容
func (p *Person) HaveBirthday() {
    p.Age++
}