golang

[mangreen]

golang面試題整理

• https://www.jishuwen.com/d/2iZz/zh-tw
• https://gophersgo.blogspot.com/2021/01/golang-interview-questions-part-1.html?fbclid=IwAR0vshsT3ILYkssa9JLay8-vElY9xIiHI0rhZicHTI212EVfZha7lucFIeA
• https://pjchender.dev/golang/control-flow

slice & channel 的底层原理和注意事项

1. unbuffered vs buffered channel
2. make 與 new 的差別
3. rune vs byte
4. type assertion
5. 使用 slice of pointers 或 slice of structs

常規性Golang面試題解析

https://www.jishuwen.com/d/2Oti/zh-tw

Go 實現常用設計模式

https://learnku.com/users/42861/articles?page=2

Go 易錯面試題彙總 (code)

https://learnku.com/articles/35063

type assertion

event, err := New(0)
if err != nil {
    t.Error(err)
}
_, ok := event.(Like)
if !ok {
    t.Error("Assertion error")
}

sync

https://juejin.cn/post/6844904175944351752

1. sync.Mutex
2. sync.RWMutex
3. sync.WaitGroup
4. sync.Once
5. sync.Map
6. sync.Pool
7. sync.Cond

匿名函數語閉包

https://openhome.cc/Gossip/Go/Closure.html

var foo = func() func() {
    var i int     
    return func() {  
        i++         
        fmt.Println(i)     
    } 
}() 
foo() // 1
foo() // 2
foo() // 3

Go semaphore

https://zhuanlan.zhihu.com/p/389718532

[mangreen]

Call by Value & Call by Reference

array & slice 參數 注意事項

https://kitecloud-backend.coderbridge.io/2020/08/15/golang-slice-%E4%BD%9C%E7%82%BA%E5%8F%83%E6%95%B8%E5%82%B3%E9%81%9E%E6%99%82%E7%9A%84%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A0%85/

傳遞參數

• Array: pass by value
• Slice: pass by reference (初始 array)
  • 函數內 append 例外 (pass by value)，要傳 pointer 才能修改外面

Golang 傳遞參數進 func ，當 pass by value 時，會在進入 func 時複製一份。

func main() {
	ary := [1]int{}

        fmt.Println("main", ary, fmt.Sprintf("%p", &ary))
	test(ary)
	fmt.Println("main", ary, fmt.Sprintf("%p", &ary))
}

func test(a [1]int) {
	a[0] = 1
	fmt.Println("test", a, fmt.Sprintf("%p", &a))
}
/*
main [0] 0xc000018030
test [1] 0xc000018038
main [0] 0xc000018030
*/

可以看到傳入 func 的 array 記憶體位址改變了

同樣的情況放到 slice 就稍微有點不同：

func main() {
	slice := []int{}
       
        fmt.Println("main", slice, fmt.Sprintf("%p", &slice))
	test(slice)
	fmt.Println("main", slice, fmt.Sprintf("%p", &slice))
}

func test(s []int) {
	s[0] = 1
	fmt.Println("test", s, fmt.Sprintf("%p", &s))
}
/*
main [0] 0xc00000c030
test [1] 0xc00000c048
main [1] 0xc00000c030
*/

一樣可以發現傳進去的 slice 記憶體位址改變了，
但最後把 slice 內容印出來顯示 slice[0] 有正確改變成 1，
這是因為 slice 的資料其實不是儲存在它自己本身上的。
所以看起來很像 pass by value 可以修改到同一個 slice，
實際上還是在操作副本。

雖然副本 slice 可以操作同一個 array，
但如果是使用 append() 這種會改變 slice len 的操作，
就只會改到副本 slice 而不是原先的 slice，

func main() {
	slice := []int{0}
	fmt.Println("main", slice, fmt.Sprintf("%p", &slice))
	test(slice)
	fmt.Println("main", slice, fmt.Sprintf("%p", &slice))
}

func test(s []int) {
        s[0] = 2
	s = append(s, 1)
	fmt.Println("test", s, fmt.Sprintf("%p", &s))
}
/*
main [0] 0xc00000c030
test [2 1] 0xc00000c060
main [2] 0xc00000c030
*/

func main() {
	slice := []int{0}
	fmt.Println("main", slice, fmt.Sprintf("%p", &slice))
	test(slice)
	fmt.Println("main", slice, fmt.Sprintf("%p", &slice))
}

func test(s []int) {
	s = append(s, 1)
        s[0] = 2
	fmt.Println("test", s, fmt.Sprintf("%p", &s))
}
/*
main [0] 0xc00000c030
test [2 1] 0xc00000c060
main [0] 0xc00000c030
*/

• slice 還沒超過 cap 時，你操作 slice 等於影響原始資料 array；
• 當 slice 持續 append 導致 cap 超過 array 長度時，
  會自動幫你生成一個 2倍大的 array 、複製資料過去、並把 slice 指向這個新的 slice。此時你操作 slice 影響到的不是原本的 array 而是 2倍大的 array
• 所以在使用 slice 時要注意是否超過 cap 導致生成新的 array，
  常見的陷阱是資料小於 cap 時可以正常透過 slice 修改 array，
  一旦超過 cap 就會發現怎麼修改都無法改變原始的 array。

建立 slice 從 array

func main() {
  arr := [5]int{10, 20, 30, 40, 50}
  
  // Create a slice from index 1 to 3 (exclusive)
  slice1 := arr[1:4] // Elements at index 1, 2, 3
  fmt.Println("Slice1:", slice1) // Slice1: [20 30 40]
  fmt.Println("Length of Slice1:", len(slice1)) // Length of Slice1: 3
  fmt.Println("Capacity of Slice1:", cap(slice1)) // Capacity of Slice1: 4 (from index 1 to 4)

  // Create a slice from index 1 to 3 (exclusive) with a capacity up to index 4
  slice2 := arr[1:4:5] // Elements at index 1, 2, 3. Capacity up to index 4.
  fmt.Println("Slice2:", slice2) // Slice2: [20 30 40]
  fmt.Println("Length of Slice2:", len(slice2)) // Length of Slice2: 3
  fmt.Println("Capacity of Slice2:", cap(slice2)) // Capacity of Slice2: 4 (from index 1 to 4)

  // 修改 slice 會修到 array
  slice1[0] = 1 
  fmt.Println(arr) // Arr: [10 1 30 40 50]
  fmt.Println(slice1) // Slice1: [1 30 40]

  // append 不會修到原本 array
  slice1 = append(slice1, []int{2, 3}...)
  fmt.Println(arr) // Arr: [10 1 30 40 50]
  fmt.Println(slice1) // Slice1: [1 30 40 2 3]
}

為何建構函式要使用 pointer

A: Go 是一個 pass by value 的程式語言，也就是每當我們把值放入函式中時，Go 會把這個值完整的複製一份，並放到新的記憶體位址

https://pjchender.dev/golang/pointers/

func main() {
	q := new(hp)
	q.name = "kevin"
	fmt.Println(q.name) // kevin

	q.rename1("ben")
	fmt.Println(q.name) // kevin

        q.rename2("ben")
	fmt.Println(q.name) // ben
}

type hp struct {
	name string
}

func (h hp) rename1(n string) {
	h.name = n
}

func (h *hp) rename2(n string) {
	h.name = n
}

深拷貝 deep copy

★ 由於 array 在go「值類型」可以直接copy
slice 則需要用 copy(sl1, sl2) 深拷貝

sl := []int{1, 2}
sl2 := sl
sl2[0] = 3
fmt.Println(sl, sl2) // [3,2] [3,2] ⭢ sl & sl2 指向相同的 array
var sl3 []int
copy(sl3, sl) // 深拷貝
sl3[0] = 4
fmt.Println(sl, sl3) // [3,2] [4,2] ⭢ sl3 指向獨立的 array 副本

ar := [2]int{1, 2}
ar2 := ar // 直接拷貝 
ar2[0] = 3
fmt.Println(ar, ar2) // [1,2] [3,2] ⭢ ar & ar2 是兩個 獨立的 array 副本

★ copy 只允許傳 slice, 傳 array 會 panic

invalid argument: copy expects slice arguments;
array 可以用 arr[:] 轉 slice

ar := [2]int{0, 1}
var ar2 [2]int
copy(ar2, ar) // panic ⭢ invalid argument: copy expects slice arguments;
copy(ar2[:], ar[:])

Go 是 pass-by-value（傳值）的語言。即使你傳的是指標，指標本身也是被複製一份傳入函數。

func main() {
    a := &Node{ 1 }
    var b *Node // b == nil
    test(a, b)
    fmt.Println(a.Val, b.Val) // panic: 因為 b 還是 nil pointer
}

func test(a, b *Node) {
    b = a // 只是把 local 指標變數 b 指向 a
}

type Node struct {
    Val int
}

修正

type Node struct {
    Val int
}

func main() {
    a := &Node{1}
    var b *Node
    test(a, &b)           // 傳入 &b 指標的指標
    fmt.Println(a.Val, b.Val) // 1, 1
    fmt.Println(fmt.Sprintf("%p", a), fmt.Sprintf("%p", b)) // 0xc000012060 0xc000012060 位址一樣
}

func test(a *Node, b **Node) {
    fmt.Println(fmt.Sprintf("%p", a), fmt.Sprintf("%p", *b))  // 0xc000012060 0x0
    *b = a                // 修改 b 所指向的指標
}

*a⭢1
**b⭢*b⭢nil

test(a, &b)

**b⭢*b 變成 **b⭢*a

[mangreen]

new(), T{}, &T{} 差別

func main() {
    q1 := new(hp)
    fmt.Println(unsafe.Sizeof(q1)) // 8
    
    q2 := hp{}
    fmt.Println(unsafe.Sizeof(q2)) // 16
    name := ""
    fmt.Println(unsafe.Sizeof(name)) // 16
    
    q3 := &hp{}
    fmt.Println(unsafe.Sizeof(q3)) // 8
}

type hp struct {
	name string
}

• new(hp) 與 &hp{} 回傳的是「指標」，記憶體大小為8
• 而 hp{} 是「struct 本體」。
• string 在 Go 裡本身也是 16 bytes 的 struct（包含指標 + 長度）。

[mangreen]

go channel

1. 無緩衝 Channel（Unbuffered Channel）

無緩衝 Channel 沒有儲存資料的空間，發送（send）與接收（receive）必須「同時就緒」，否則會阻塞（block）。

核心特性

本質是「同步通訊」：發送者會阻塞到有接收者接收資料，接收者也會阻塞到有發送者傳送資料。

常見情境

情境 1：正常同步傳輸

若 Goroutine A 透過無緩衝 Channel 傳送資料，同時 Goroutine B 接收，兩者會在 Channel 處「交握」後繼續執行。

示例：

ch := make(chan int) // 預設無緩衝，等同 make(chan int, 0)
go func() {
    ch <- 10 // 發送者：阻塞至有接收者
}()
fmt.Println(<-ch) // 接收者：阻塞至有發送者，列印 10

情境 2：單獨發送 / 接收（阻塞死鎖）

若在同一 Goroutine 中單獨執行「發送」或「接收」，會因沒有對方就緒而永久阻塞，最終觸發死鎖（deadlock）。

錯誤示例：

ch := make(chan int)
ch <- 10 // 同一 Goroutine 無接收者，阻塞死鎖

2. 有緩衝 Channel（Buffered Channel）

有緩衝 Channel 透過指定「容量（capacity）」儲存資料，發送者僅在緩衝滿時阻塞，接收者僅在緩衝空時阻塞，本質是「非同步通訊」。

核心特性

• 容量透過 make(chan T, cap) 設定，必須是大於 0 的整數；
• 透過 len(ch) 可查看當前緩衝中的資料數量，cap(ch) 查看總容量。

常見情境

情境 1：緩衝未滿 / 未空（正常非同步）

發送者傳送資料後直接繼續執行（無需等待接收者），接收者在緩衝有資料時可直接取走。

ch := make(chan int, 2) // 容量 2 的有緩衝 Channel
ch <- 1 // 緩衝未滿，發送後不阻塞
ch <- 2 // 緩衝仍未滿，發送後不阻塞
fmt.Println(len(ch)) // 列印 2（當前資料數）
fmt.Println(<-ch)    // 接收 1，緩衝剩 1
fmt.Println(<-ch)    // 接收 2，緩衝空

情境 2：緩衝已滿（發送阻塞）

若緩衝中的資料數達到容量上限，後續發送操作會阻塞，直到有接收者取走資料、釋放緩衝空間。

示例：

ch := make(chan int, 2)
ch <- 1
ch <- 2 // 緩衝已滿
ch <- 3 // 此處會阻塞，直到有接收者取走資料

func main() {
    
    ch := make(chan int, 2)

    go func() {
        for {
            fmt.Print(<-ch) // // 012End! 就結束  後面的來不及進入 ch 無法阻塞
        }
    }() 
    
    for i := range 6 {
        ch <- i
    }

    fmt.Println("End!")

}

func main() {
    
    ch := make(chan int) // 無 buffer

    go func() {
        for {
            fmt.Print(<-ch) // 012345End!
        }
    }() 
    
    for i := range 6 {
        ch <- i
    }

    fmt.Println("End!")

}

情境 3：緩衝已空（接收阻塞）

若緩衝中沒有資料，後續接收操作會阻塞，直到有發送者傳送資料。

示例：

ch := make(chan int, 2)
fmt.Println(<-ch) // 緩衝空，接收阻塞

3. go channel 關閉的那些事兒

透過 close(ch) 關閉 Channel，關閉後的 Channel 有嚴格規則，違反會導致 panic。

• https://juejin.cn/post/7033671944587182087

什麼情況下關閉 channel 會造成 panic ？

1. 未初始化時關閉
2. 重複關閉
3. 關閉後傳送
4. 傳送時關閉

// 1.未初始化時關閉
func TestCloseNilChan(t *testing.T) {
   var errCh chan error
   close(errCh)
   
   // Output:
   // panic: close of nil channel
}

// 2.重複關閉
func TestRepeatClosingChan(t *testing.T) {
   errCh := make(chan error)
   var wg sync.WaitGroup
   wg.Add(1)

   go func() {
      defer wg.Done()
      close(errCh)
      close(errCh)
   }()

   wg.Wait()
   
   // Output:
   // panic: close of closed channel
}

// 3.關閉後傳送
func TestSendOnClosingChan(t *testing.T) {
   errCh := make(chan error)
   var wg sync.WaitGroup
   wg.Add(1)

   go func() {
      defer wg.Done()
      close(errCh)
      errCh <- errors.New("chan error")
   }()

   wg.Wait()
   
   // Output:
   // panic: send on closed channel
}

// 4.傳送時關閉
func TestCloseOnSendingToChan(t *testing.T) {
   errCh := make(chan error)
   var wg sync.WaitGroup
   wg.Add(1)

   go func() {
      defer wg.Done()
      defer close(errCh)

      go func() {
         errCh <- errors.New("chan error") // 由於 chan 沒有緩衝佇列，程式碼會一直在此處阻塞
      }()

      time.Sleep(time.Second) // 等待向 errCh 傳送資料
   }()

   wg.Wait()

   // Output:
   // panic: send on closed channel
}

Q: go channel 關閉後，讀取該 channel 會?

A: 永遠不會阻塞，且只會輸出對應類型的零值。

func TestReadFromClosedChan(t *testing.T) {
   var errCh = make(chan error)

   go func() {
      defer close(errCh)
      errCh <- errors.New("chan error")
   }()

   go func() {
      for i := 0; i < 3; i++ {
         fmt.Println(i, <-errCh)
      }
   }()

   time.Sleep(time.Second)
   
   // Output:
   // 0 chan error
   // 1 <nil>
   // 2 <nil>
}

4. 其他易忽略情境

情境 1：nil Channel 的所有操作都阻塞

若 Channel 宣告後未初始化（即 var ch chan int，此時 ch 是 nil），對其執行「發送」「接收」「關閉」都會永久阻塞（不會觸發 panic，但會導致死鎖）。

錯誤示例：

var ch chan int // nil Channel
// ch <- 1    // 阻塞
// <-ch       // 阻塞
// close(ch)  // 阻塞（nil 不可關閉）

情境 2：單向 Channel（限制傳輸方向）

透過「單向 Channel」可限制 Goroutine 只能執行「發送」或「接收」，增強程式安全性（避免誤操作）。

• 只能發送：chan<- T（箭頭指向 Channel，表示資料傳入）；
• 只能接收：<-chan T（箭頭指向外部，表示資料傳出）。

示例：

// 建立有緩衝 Channel，轉換為單向 Channel 傳入函數
ch := make(chan int, 2)
sendOnly := chan<- int(ch) // 只能發送的 Channel
recvOnly := <-chan int(ch) // 只能接收的 Channel

sendOnly <- 1 // 合法
// <-sendOnly  // 非法：不能接收
// recvOnly <- 1 // 非法：不能發送
fmt.Println(<-recvOnly) // 合法

情境 3：使用 select 處理多 Channel

當需要同時監聽多個 Channel 的「發送 / 接收」事件時，可透過 select 實現，避免單一 Channel 阻塞導致整個 Goroutine 卡住。

特性：

select 會同時監聽所有 case 中的 Channel 操作；

• 若多個 case 同時就緒，隨機選擇一個執行；
• 若所有 case 都阻塞，且有 default 分支，則執行 default（避免阻塞）；
• 若所有 case 都阻塞且無 default，則 select 會阻塞，直到某個 case 就緒。

示例（監聽兩個 Channel 接收）：

ch1 := make(chan int)
ch2 := make(chan int)

go func() { ch1 <- 1 }()
go func() { ch2 <- 2 }()

select {
case val := <-ch1:
    fmt.Println("從 ch1 接收：", val)
case val := <-ch2:
    fmt.Println("從 ch2 接收：", val)
}

總結：Channel 行為關鍵判斷

遇到 Channel 問題時，可按以下步驟快速判斷行為：

• 是否為 nil：是 → 所有操作阻塞；否 → 進下一步；
• 是否有緩衝：
  • 無緩衝 → 發送 / 接收必須同時就緒，否則阻塞；
  • 有緩衝 → 發送阻塞（滿）、接收阻塞（空），否則非同步；
• 是否已關閉：
  • 關閉後 → 不可發送（panic），可接收（直到空，後續返回零值）；
  • 未關閉 → 按上述規則執行。

[mangreen]

Golang 中 Channel 对阻塞 goroutine 的唤醒顺序分析

https://blog.csdn.net/shida_csdn/article/details/88344017

Q: 當 Channel 可用時，它是按照什麼順序喚醒等待的 goroutine 協程的呢？

A: 先阻塞的先被喚醒！

多個 goroutine 等待讀取 ch，雖然誰先呼叫讀取是不確定的，
但是，誰先呼叫了讀取並被阻塞，誰就能在通道資料可用時先被喚醒

[mangreen]

Golang 的 GC學習

Go 垃圾回收

https://juejin.im/post/6844903917650722829
https://codertw.com/%E7%A8%8B%E5%BC%8F%E8%AA%9E%E8%A8%80/752833/#outline__2
https://www.threads.com/@chill.vic.22/post/DOw16mCkp4v

STW（Stop-The-World）觸發的時間

一次GC有兩次觸發STW，一次是GC的開始階段，主要是開啟寫屏障和輔助GC等操作 另外就是表記完成之後，重新掃描部分根對象，停用寫屏障

Go 什麼時候會觸發 GC？

https://cloud.tencent.com/developer/article/1900650
https://anakinsun.com/post/golang-gc/

1. 系統觸發：

執行階段自行根據內建的條件，檢查、發現到，則進行 GC 處理，維護整個應用程式的可用性。

1. gcTriggerHeap：當所分配的堆大小達到閾值（由控製器計算的觸發堆的大小）時，將會觸發。
2. gcTriggerTime：當距離上一個 GC 週期的時間超過一定時間時，將會觸發。-時間週期以 runtime.forcegcperiod 變數為準，默認 2 分鐘。
3. gcTriggerCycle：要求啟動新一輪的GC, 已啟動則跳過, 手動觸發GC的runtime.GC()會使用這個條件
4. gcTriggerAlways: 強制觸發GC

2. 手動觸發：

開發者在業務程式碼中自行呼叫 runtime.GC 方法來觸發 GC 行為。
在手動觸發的場景下，Go 語言中僅有 runtime.GC 方法可以觸發，也就沒什麼額外的分類的。

三色標記的過程

1. 所有對象最開始都是白色。
2. 從 root 開始找到所有可達對象，標記為灰色，放入待處理佇列。
3. 遍歷灰色對象佇列，將其引用對象標記為灰色放入待處理佇列，自身標記為黑色。
4. 處理完灰色對象佇列，執行清掃工作，將所有還是白色未被引用的對象刪除。

[mangreen]

defer

defer 是延遲執行，可以將其後面的程式碼延後至函式結束時執行。Defer 可以 stack，執行順序先進後出

func main() {  
    fmt.Println("defer begin")
    defer fmt.Println("Hello World")
    defer fmt.Println("Hey World")
    defer fmt.Println("Hi World") 
    fmt.Println("defer end") 
}  
/* print out: 
defer begin 
defer end 
Hi World
Hey World
Hello World
*/

recover

1. recover 可捕捉系統自動產生或手動設定產生的 panic 錯誤，回復系統以避免程序崩潰。成功捕獲後，程式會從恐慌點之後繼續執行。
2. recover 必須和 defer 配合使用！recover 必須和 defer 配合使用！recover 必須和 defer 配合使用！（很重要）
3. 若無恐慌，recover() 回傳 nil

package main
import "fmt"

func main() {
	fmt.Println("Taiwan: Here Comes 2021")

	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
			fmt.Println("Don't panic! We got vaccinated!")
		}
		fmt.Println("Life still moves on!")
	}()

	panic("Oh! No! COVID Pandemic!")
}

[mangreen]

操作系统内核
+-----------------------------------------+
|  调度器                                  |
|  +--------+  +--------+  +--------+     |
|  |Thread 1|  |Thread 2|  |Thread 3|     |  ← 每个线程独立栈空间
|  +--------+  +--------+  +--------+     |
+-----------------------------------------+

Go 运行时调度器
+---------------------------------------------------+
|  +----------+ +----------+  +----------+ +---+    |
|  |Goroutine1| |Goroutine2|  |Goroutine3| |...     |  ← 数千个协程
|  +----------+ +----------+  +----------+ +---+    |
|       ↓            ↓            ↓                 |
|  +------------------------+  +----------------+   |
|  |     OS Thread 1        |  |   OS Thread 2  |   |  ← 少量线程（如 CPU 核心数）
|  +------------------------+  +----------------+   |
+---------------------------------------------------+

Goroutine 與 Thread 比較

https://studygolang.com/articles/23191?utm_source=tuicool&utm_medium=referral

程式 (Program)、進程 (Process)、線程 (Thread)、協程 (coroutine/goroutine)

https://ithelp.ithome.com.tw/articles/10242047

GPM

https://my.oschina.net/aom/blog/4279175
理解 M: Machine、P: Processor、G:Goroutine 三者的關係，可以通過經典的地鼠推車搬磚的模型來說明其三者關係：
地鼠(Gopher)的工作任務是：工地上有若干磚頭，地鼠借助小車把磚頭運送到火種上去燒製。M 就可以看作圖中的地鼠，P 就是小車，G 就是小車裡裝的磚。

Scheduler原理以及查看Goroutine执行

https://cloud.tencent.com/developer/news/327423

[mangreen]

Go 1.22 修改for迴圈作用域

Go 1.22 對 for 迴圈的變數作用域進行了修改，主要影響迴圈變數在 goroutine 中的行為：

舊版本（1.21 及之前）

迴圈變數是「整個迴圈共用一個」，goroutine 可能抓到同一個變數的最後值：

package main

import (
	"fmt"
	"time"
)

func main() {
	for i := 0; i < 3; i++ {
		go func() {
			fmt.Println(i) // 可能輸出 3、3、3（非預期）
		}()
	}
	time.Sleep(time.Second)
}

新版本（1.22 及之後）

每次迭代會建立獨立的變數，goroutine 會抓到當次迭代的值：

package main

import (
	"fmt"
	"time"
)

func main() {
	for i := 0; i < 3; i++ {
		go func() {
			fmt.Println(i) // 會輸出 0、1、2（順序可能不同）
		}()
	}
	time.Sleep(time.Second)
}

關鍵差異

• 舊版：所有迭代共用同一個迴圈變數，goroutine 引用的是同一個變數地址，容易出錯。
• 新版：每次次迭代有獨立變數，goroutine 會捕獲當前迭代的值，行為更直覺。

此修改讓程式碼行為更符合直覺，減少因共用變數導致的併發錯誤。

[mangreen]

「即時函數」指的是匿名函數（anonymous function）

在 Go 中，「即時函數」指的是匿名函數（anonymous function）立即執行的用法，宣告後馬上調用，常用於常用於封裝臨時邏輯或建立作用域。

示範

func main() {
    // 定義即時函數並立即執行
    func() {
        fmt.Println("這是即時函數")
    }() // 最後尾的 () 表示立即調用

    // 帶參數的即時函數
    func(msg string) {
        fmt.Println("訊息:", msg)
    }("Hello, 即時函數")
}

特點：

沒有函數名，直接使用 func 宣告
宣告後馬上用 () 調用，不需要單獨命名
可用以封裝臨時邏輯，避免污染外部作用域
常用於初始化操作或簡單的一次性任務

用途：臨時需要一段程式碼塊，又不想單獨定義函數時使用。

[mangreen]

Go 中 Stack 與 Heap 記憶體管理（繁中精簡版）

• https://josh-ku.com/post/go-stack-heap/

Go 透過自動記憶體管理（逃逸分析 + GC）優化效能，Stack 與 Heap 是兩個核心記憶體區域，差異與管理邏輯如下：

1. Stack（堆疊）

• 靜態配置記憶體
• 特性：線性結構、先進後出（LIFO），每個 Goroutine 有獨立 Stack（預設初始大小 2KB，可動態增減）。
• 儲存內容：函式區域變數、參數、返回值等「短期存活」的資料。
• 管理方式：由 Go 執行時自動管理，無需 GC。函式呼叫時分配記憶體，函式結束後自動彈出（彈棧）釋放，速度極快。
• 優劣：速度快、無 GC 開銷；但大小有限，不適合儲存大量 / 長期資料。

2. Heap（堆積）

• 動態配置記憶體,需自行回收(golang使用GC動態回收)
• 特性：非線性結構，所有 Goroutine 共享，記憶體空間更大。
• 儲存內容：「長期存活」或「無法在編譯期確定大小」的資料，例如動態建立的切片（如 make([]int, 1000)）、指標指向的複雜結構、跨 Goroutine 共享的變數。
• 管理方式：需透過 GC（垃圾回收） 自動回收未被引用的記憶體，避免記憶體泄漏。
• 優劣：空間大、靈活；但 GC 會帶來短暫效能開銷，分配 / 釋放速度比 Stack 慢。

3. 核心：逃逸分析（Escape Analysis）

Go 編譯器透過「逃逸分析」決定變數存 Stack 還是 Heap，規則簡化如下：

• 不逃逸：變數僅在當前函式內使用，存 Stack（如 func f() { x := 1 } 中的 x）。
• 逃逸：變數需跨函式傳遞（如返回指標 / 切片）、跨 Goroutine 共享，或大小動態變化，則「逃逸到 Heap」（如 func f() *int { x := 1; return &x } 中的 x）。

可透過編譯指令查看逃逸情況：

go build -gcflags="-m" 程式檔.go。

總結

維度	Stack	Heap
歸屬	每個 Goroutine 獨有	所有 Goroutine 共享
管理方式	自動彈棧（無 GC）	GC 回收
速度	快	慢
儲存對象	短期、小體積變數	長期、大體積 / 動態變數
關鍵決策	編譯期逃逸分析判定	編譯期逃逸分析判定

[mangreen]

Golang 中所有阻塞（Blocking）的方式

1. 通道（Channel）操作

• 發送操作（ch <- value）：當通道已滿時，發送操作會阻塞
• 接收操作（value <- ch）：當通道為空時，接收操作會阻塞
• range 循環讀取通道：直到通道關閉才會停止阻塞

ch := make(chan int, 1)
ch <- 1
ch <- 2  // 阻塞，因為緩衝區已滿

value := <-ch  // 正常接收
value = <-ch   // 阻塞，因為通道已空

2. 同步原語 (sync)

• sync.WaitGroup：Wait() 方法會阻塞直到計數歸零
• sync.Mutex 與 sync.RWMutex：
  • Lock() 會阻塞直到獲取到鎖
  • RLock() 會阻塞直到獲取到讀鎖
• sync.Cond：Wait() 方法會阻塞直到被 Signal() 或 Broadcast() 喚醒

var wg sync.WaitGroup
wg.Add(1)
wg.Wait()  // 阻塞，直到調用 wg.Done()

var mu sync.Mutex
mu.Lock()  // 獲取鎖，若已被鎖定則阻塞

3. select 語句

select 本身會阻塞，直到其中一個 case 可以執行：

• 當所有 case 都是阻塞操作時，select 會整體阻塞
• 若沒有 default 分支，select 會一直等待直到某個通道操作可執行

ch1 := make(chan int)
ch2 := make(chan int)

// 這個 select 會一直阻塞，直到 ch1 或 ch2 有數據
select {
case x := <-ch1:
    fmt.Println("收到 ch1 的數據:", x)
case y := <-ch2:
    fmt.Println("收到 ch2 的數據:", y)
}

for + select 組合

這是 Go 中處理多通道的經典模式，會長期阻塞等待事件：

ch1 := make(chan int)
ch2 := make(chan string)
done := make(chan bool)

for {
    select {
    case x := <-ch1:
        fmt.Println("ch1:", x)
    case s := <-ch2:
        fmt.Println("ch2:", s)
    case <-done:
        fmt.Println("退出循環")
        return  // 結束阻塞
    }
}

4. for 迴圈

for 迴圈本身不阻塞，但常與阻塞操作配合形成「持續阻塞等待」的模式：

無限循環 + 通道接收

ch := make(chan int)

// 無限循環接收通道數據，會一直阻塞等待新數據
for {
    data := <-ch  // 阻塞點
    fmt.Println("收到數據:", data)
}

for range 遍歷通道

這是一種常見的阻塞讀取模式，會持續阻塞直到通道關閉：

ch := make(chan int)

// 會阻塞等待，直到通道被關閉且所有數據被讀取完畢
for data := range ch {
    fmt.Println("收到數據:", data)
}

總結

select 本身會阻塞，直到某個 case 可執行
for 迴圈本身不阻塞，但與阻塞操作（如通道接收）結合後，會形成持續阻塞的效果
兩者經常一起使用，實現「長期等待多個事件」的功能，這是 Go 併發編程中的常見模式

這些組合方式讓開發者可以靈活地處理多種阻塞場景，尤其是在需要持續監聽多個通道時非常有用。

5. 計時器

• time.Sleep()：會阻塞指定的時間
• time.After()：返回一個通道，在指定時間後發送訊號
• time.Timer()：到固定時間後會執行一次 ex. 1秒後執行
• time.Ticker：定期發送訊號的計時器 ex. 每過1秒執行1次

time.Sleep(1 * time.Second)  // 阻塞 1 秒鐘

<-time.After(2 * time.Second)  // 阻塞 2 秒鐘

6. 其他阻塞操作

檔案 I/O 操作

檔案讀寫操作預設是阻塞的：
os.ReadFile() 讀取檔案
file.Read() 和 file.Write() 操作
file.Close() 關閉檔案

file, _ := os.Open("file.txt")
buf := make([]byte, 1024)
n, _ := file.Read(buf)  // 阻塞直到讀取完成

網路操作

所有網路 I/O 操作預設都是阻塞的：
net.Dial() 連接網路時
conn.Read() 和 conn.Write() 進行讀寫時
listener.Accept() 等待新連接時

conn, err := net.Dial("tcp", "example.com:80")
buf := make([]byte, 1024)
n, err := conn.Read(buf)  // 阻塞直到有數據到來

某些標準庫函數

如 fmt.Scan() 等待用戶輸入

var input string
fmt.Scan(&input)  // 阻塞直到用戶輸入

外部程式呼叫

如 exec.Command("cmd").Run()

如何避免不必要的阻塞？

• 使用帶緩衝的通道
• 配合 select 語句使用非阻塞操作
• 使用 context.Context 設置超時
• 利用 goroutine 將阻塞操作放在後台執行

這些阻塞機制是 Go 併發模型的重要組成部分，合理使用可以幫助我們編寫高效的併發程式。

[mangreen]

slice[low:high:max] (切片表達式)

关键区别总结:

• high 控制切片当前包含的元素数量
• max 控制切片最多能容纳的元素数量（不重新分配内存）
• 当 max > high 时，切片有扩展空间，append 操作可能修改原数组
• 当 max == high 时，切片没有扩展空间，append 会创建新的底层数组

通过控制 max，可以限制切片对原数组的修改范围，提高代码安全性。例如在传递切片时，使用 max=high 可以防止函数意外修改原数组中未被切片包含的元素。

基礎用法

func main() {
    a := [5]int{10, 20, 30, 40, 50}
    
    // high=4, max=5
    s1 := a[1:4:5]
    fmt.Printf("s1: 元素=%v, 长度=%d, 容量=%d\n", s1, len(s1), cap(s1))
    // 输出: s1: 元素=[20 30 40], 长度=3, 容量=4
    // 长度=4-1=3，容量=5-1=4
    
    // high=3, max=4
    s2 := a[1:3:4]
    fmt.Printf("s2: 元素=%v, 长度=%d, 容量=%d\n", s2, len(s2), cap(s2))
    // 输出: s2: 元素=[20 30], 长度=2, 容量=3
    // 长度=3-1=2，容量=4-1=3
}

切片扩展的差异

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    
    // 情况1：max > high
    s1 := arr[1:3:5] // len=2, cap=4
    fmt.Println("s1:", s1) // [2 3] 實際上是 [2 3 _ _]
    s1 = append(s1, 6) // 仍使用原数组
    s1 = append(s1, 7) // 仍使用原数组
    fmt.Println("s1对应的数组:", s1) // [2 3 6 7]
    fmt.Println("原数组arr:", arr)   // [1 2 3 6 7]（被修改）
    
    // 情况2：max == high
    s2 := arr[1:3:3] // len=2, cap=2
    fmt.Println("s2:", s2) // [2 3]
    s2 = append(s2, 8) // 创建新数组
    s2 = append(s2, 9) // 使用新数组
    fmt.Println("s2对应的数组:", s2) // [2 3 8 9]
    fmt.Println("原数组arr:", arr)   // [1 2 3 6 7]（未被继续修改）
}

[mangreen]

Array, Slice, Map 的比较 (==)

类型	能否用 == 直接比较内容	特殊说明
Array	能	必须长度相同且元素类型支持 ==
Slice	不能	== 只能用于判断是否为 nil，内容需手动比较
Map	不能	== 只能用于判断是否为 nil，内容需手动比较

Array（数组）

数组是值类型，并且当数组的元素类型支持 == 比较且数组长度相同时，可以直接使用 == 比较。

func main() {
    // 示例1：长度相同，元素相同
    a := [2]int{1, 2}
    b := [2]int{1, 2}
    fmt.Println(a == b) // 输出: true

    // 示例2：长度相同，元素不同
    c := [2]int{1, 3}
    fmt.Println(a == c) // 输出: false

    // 示例3：长度不同（编译错误）
    d := [3]int{1, 2, 3}
    fmt.Println(a == d) // 错误：数组长度不同不能比较
}

Slice（切片）

切片不能直接使用 == 比较，即使两个切片的元素和长度完全相同也不行。== 只能用于判断切片是否为 nil。

func main() {
    // 示例1：直接比较切片（编译错误）
    s1 := []int{1, 2}
    s2 := []int{1, 2}
    // fmt.Println(s1 == s2) // 错误：切片不能直接用 == 比较

    // 示例2：判断切片是否为 nil
    var s3 []int // 未初始化的切片为 nil
    s4 := []int{} // 空切片但不是 nil
    fmt.Println(s3 == nil) // 输出: true
    fmt.Println(s4 == nil) // 输出: false

    // 示例3：比较切片内容的正确方式
    fmt.Println(equalSlice(s1, s2)) // 输出: true
}

// 自定义函数比较两个 int 切片的内容
func equalSlice(a, b []int) bool {
    if len(a) != len(b) {
        return false
    }
    for i := range a {
        if a[i] != b[i] {
            return false
        }
    }
    return true
}

注意：如果需要比较切片内容，必须手动实现（如上述 equalSlice 函数），或使用标准库中对应类型的比较函数（如 bytes.Equal 用于比较 []byte）。

Map（映射）

映射同样不能直接使用 == 比较，== 只能用于判断映射是否为 nil。

func main() {
    // 示例1：直接比较 map（编译错误）
    m1 := map[string]int{"a": 1}
    m2 := map[string]int{"a": 1}
    // fmt.Println(m1 == m2) // 错误：map 不能直接用 == 比较

    // 示例2：判断 map 是否为 nil
    var m3 map[string]int // 未初始化的 map 为 nil
    m4 := make(map[string]int) // 空 map 但不是 nil
    fmt.Println(m3 == nil) // 输出: true
    fmt.Println(m4 == nil) // 输出: false

    // 示例3：比较 map 内容的正确方式
    fmt.Println(equalMap(m1, m2)) // 输出: true
}

// 自定义函数比较两个 map[string]int 的内容
func equalMap(a, b map[string]int) bool {
    if len(a) != len(b) {
        return false
    }
    for k, v := range a {
        if bv, ok := b[k]; !ok || bv != v {
            return false
        }
    }
    return true
}

注意：比较 map 内容时，需要同时检查键的存在性和对应的值是否相等。