Golang 备忘录
{Back to Index}  Expand All Details on Page

var ch chan in
// 这种方式声明的管道，值为 nil
// 读写 nil 管道均会永久阻塞。关闭的管道仍然可以读取数据，向关闭的管道写数据会触发 panic

// nil channel 在某些时候有些妙用，例如在 select 的某个 case 分支 A 将其它某 case 分支 B 所操作的 channel 设置为 nil ，这将会禁用 case 分支 B

ch1 := make(chan string)        // without buffer
ch1 := make(chan string, 5)     // with buffer

var counter int = 0
var ch = make(chan int, 1)
func Worker() {
    ch <- 1
    counter++
    <-ch
}

func ChanParamRW(ch chan int) {
    // 管道可读写
}

func ChanParamR(ch <-chan int) {
    // 只能从管道读取数据
}

func ChanParamW(ch chan<- int) {
    // 只能向管道写入数据
}

// Create a slice of strings.
// Contains a length and capacity of 5 elements.
slice := make([]string, 5)

// Create a slice of integers.
// Contains a length and capacity of 3 elements.
slice := []int{10, 20, 30}

// Create a slice of strings. (slice with a length and capacity of 100 elements)
// Initialize the 100th element with an empty string.
slice := []string{99: ""}

// Create a nil slice of integers.
var slice []int

// Create Empty Slice
// Use make to create an empty slice of integers.
slice := make([]int, 0)
// Use a slice literal to create an empty slice of integers.
slice := []int{}

// Create a map with a key of type string and a value of type int.
dict := make(map[string]int)
// Create a map with a key and value of type string.
// Initialize the map with 2 key/value pairs.
dict := map[string]string{"Red": "#da1337", "Orange": "#e95a22"}

func add(a, b int) int {
    return a + b
}

f := add  // f 是一个函数值

// runtime/runtime2.go
type funcval struct {
    fn uintptr  // 函数代码的入口地址
    // 闭包捕获的变量紧跟其后...
}

func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

type Dog struct{ Name string }

func (d Dog) Bark() string {
    return d.Name + ": woof!"
}

// 编译器实际生成的等价函数：
// func Dog_Bark(d Dog) string { ... }

// 以下两种调用等价
dog := Dog{"Buddy"}
dog.Bark()                    // 方法调用
Dog.Bark(dog)                 // 函数调用（方法表达式）

var x float64 = 3.14

t := reflect.TypeOf(x)   // 提取 eface 中的 _type 指针 → 得到类型元数据
v := reflect.ValueOf(x)  // 提取 eface 中的 data 指针  → 得到值的副本

func main() {
    select {}
}

// 该函数返回一个管道，可用于在函数之间传递，但该管道会在指定时间后自动关闭
func waitForStopOrTimeout(stopCh <-chan struct{}, timeout time.Duration) <-chan struct{} {
    stopChWithTimeout := make(chan struct{})
    go func() {
        select {
        case <-stopCh: // 自然结束
        case <-time.After(timeout):    // 最长等待时间长
        }
        close(stopChWithTimeout) }()
    return stopChWithTimeout

}

type Animal struct {
    Name string
    Age  int
}

func (a Animal) Speak() string {
    return a.Name + " makes a sound"
}

type Dog struct {
    Animal        // 嵌入，Dog "继承"了 Animal 的字段和方法
    Breed string
}

d := Dog{Animal{"Buddy", 3}, "Labrador"}
d.Name              // ✅ 直接访问，不用 d.Animal.Name
d.Speak()           // ✅ 直接调用，不用 d.Animal.Speak()

// 给任何结构体加锁能力
type SafeCounter struct {
    sync.Mutex             // 嵌入锁
    count int
}

func (c *SafeCounter) Inc() {
    c.Lock()               // 直接调用，不用 c.Mutex.Lock()
    defer c.Unlock()
    c.count++
}

type Reader interface {
    Read(p []byte) (n int, err error)
}

type MyReader struct {
    io.Reader              // 嵌入，自动实现 io.Reader 接口
    readCount int
}

// 可以直接传给需要 io.Reader 的地方
func process(r io.Reader) { ... }

f, _ := os.Open("file.txt")
mr := MyReader{Reader: f}
process(mr)                // ✅ MyReader 实现了 io.Reader

type Base struct{}
func (b Base) String() string { return "base" }

type Extended struct {
    Base
}
func (e Extended) String() string { return "extended" }  // 覆盖

e := Extended{}
e.String()        // "extended"（调用 Extended 的方法）
e.Base.String()   // "base"（仍可访问原始方法）

// 嵌入值 - 拷贝语义
type A struct {
    Inner       // Outer 包含 Inner 的完整拷贝
}

// 嵌入指针 - 共享语义（更常用于大结构体）
type B struct {
    *Inner      // Outer 只包含指针，多个实例可共享
}

type Config struct {
    Debug bool
    Port  int
}

type ServerB struct {
    *Config  // 嵌入指针
    Name string
}

func TestEmbedPointer(t *testing.T) {
    cfg := &Config{true, 8080}

    s1 := ServerB{cfg, "server1"}
    s2 := ServerB{cfg, "server2"}  // 共享同一个 Config

    s2.Debug = false  // 修改 s2

    fmt.Println(s1.Debug)  // false  ← s1 也变了！
    fmt.Println(s2.Debug)  // false
}

type T1 struct{}

func (T1) T1M1()   {}
func (T1) T1M2()   {}
func (*T1) PT1M3() {}

type T2 struct{}

func (T2) T2M1()   {}
func (T2) T2M2()   {}
func (*T2) PT2M3() {}

type T struct {
    T1
    *T2
}

// runtime/runtime2.go
type eface struct {
    _type *_type          // 指向类型信息
    data  unsafe.Pointer  // 指向实际数据
}

// runtime/runtime2.go
type iface struct {
    tab  *itab            // 类型信息 + 方法表
    data unsafe.Pointer   // 指向实际数据
}