Go | 了解「內建函式」應用

💬 簡介

Go 語言提供了多種強大的內建函式，這些函式能夠幫助我們簡化程式設計、提高效率。了解並善用這些內建函式，能讓我們寫出更加簡潔、高效且易讀的程式。

本文將介紹 Go 語言中的常用內建函式，並通過範例展示如何在日常開發中應用這些函式。

圖片來源：Gophers

🔎 什麼是內建函式？

內建函式是 Go 語言中已經實現並隨語言提供的函式。這些函式不需要額外的導入，即可在程式中使用。Go 的內建函式涵蓋了多方面的功能，從資料結構操作到數字處理，從字串處理到 I/O 操作，都提供了豐富的內建支持。

Go 的內建函式在官方文件中有詳細的說明，你可以根據需要查找相關的函式。

常見的內建函式範例：

• len()：返回資料結構（如字串、切片、陣列等）的長度。
• cap()：返回切片的容量。
• append()：向切片添加元素。
• copy()：將一個切片的元素複製到另一個切片。
• make()：創建並初始化內建資料結構（如切片、映射、通道）。
• delete()：從映射中刪除元素。
• close()：關閉通道。
• panic()：觸發恐慌終止程式。
• recover()：從恐慌中恢復程式。
• print() 和 println()：輸出資訊。
• complex()、real()、imag()：處理複數。

🛠 內建函式應用範例

1️⃣ 使用 len() 獲取資料結構長度

len() 函式用來返回字串、切片、陣列、映射等資料結構的長度。這在處理資料結構時非常有用。

• 範例：獲取字串長度

  1 2 3 4 5 6 7 8

  package main import "fmt" func main() { str := "Hello, Go!" fmt.Println("字串長度:", len(str)) // 輸出: 11 }

  輸出結果：

  1

  字串長度: 11

  📝 使用 len() 函式可以方便地獲取資料結構的長度。

2️⃣ 使用 cap() 獲取切片的容量

cap() 函式返回切片的容量，即切片底層陣列的大小。這對於動態調整切片大小的程式設計很有幫助。

• 範例：獲取切片的容量

  1 2 3 4 5 6 7 8

  package main import "fmt" func main() { slice := make([]int, 5, 10) // 創建長度為 5，容量為 10 的切片 fmt.Println("切片容量:", cap(slice)) // 輸出: 10 }

  輸出結果：

  1

  切片容量: 10

  📝 使用 cap() 函式可以了解切片的容量，這有助於管理切片的記憶體使用。

3️⃣ 使用 append() 向切片添加元素

append() 函式是 Go 中用來向切片追加元素的內建函式。它會自動擴展切片的容量，並返回一個新的切片。

• 範例：使用 append() 向切片添加元素

  1 2 3 4 5 6 7 8 9

  package main import "fmt" func main() { slice := []int{1, 2, 3} slice = append(slice, 4, 5) // 向切片添加元素 fmt.Println("新增後的切片:", slice) // 輸出: [1 2 3 4 5] }

  輸出結果：

  1	新增後的切片: [1 2 3 4 5]

  📝 append() 函式允許我們在切片中動態添加元素，這在處理可變長度資料時特別有用。

4️⃣ 使用 copy() 複製切片

copy() 函式用來將一個切片的內容複製到另一個切片中。它會將源切片中的元素複製到目標切片，並返回複製的元素數量。

• 範例：使用 copy() 複製切片

  1 2 3 4 5 6 7 8 9 10

  package main import "fmt" func main() { src := []int{1, 2, 3, 4, 5} dest := make([]int, len(src)) copy(dest, src) // 複製 src 到 dest fmt.Println("目標切片:", dest) // 輸出: [1 2 3 4 5] }

  輸出結果：

  1	目標切片: [1 2 3 4 5]

  📝 copy() 函式能夠高效地將切片或陣列的內容複製到另一個資料結構中，這在資料操作時非常有用。

5️⃣ 使用 make() 創建資料結構

make() 函式是 Go 中用來創建切片、映射或通道的內建函式。它不僅分配記憶體，還會初始化資料結構。

• 範例：使用 make() 創建切片

  1 2 3 4 5 6 7 8 9

  package main import "fmt" func main() { slice := make([]int, 5, 10) // 創建長度為 5，容量為 10 的切片 fmt.Println("切片長度:", len(slice)) // 輸出: 5 fmt.Println("切片容量:", cap(slice)) // 輸出: 10 }

  輸出結果：

  1 2	切片長度: 5 切片容量: 10

  📝 make() 函式用於創建具有指定長度和容量的資料結構，這對於動態處理資料非常有用。

6️⃣ 使用 delete() 刪除映射中的元素

delete() 函式用於從映射中刪除指定的元素。

• 範例：使用 delete() 刪除映射元素

  1 2 3 4 5 6 7 8 9

  package main import "fmt" func main() { m := map[string]int{"a": 1, "b": 2, "c": 3} delete(m, "b") // 刪除鍵 "b" 的元素 fmt.Println("刪除後的映射:", m) // 輸出: map[a:1 c:3] }

  輸出結果：

  1	刪除後的映射: map[a:1 c:3]

  📝 使用 delete() 函式可以從映射中刪除指定的鍵值對，這在處理資料時非常方便。

7️⃣ 使用 close() 關閉通道

close() 函式用來關閉通道。一旦通道被關閉，無法再向其發送資料，但仍然可以接收資料。

• 範例：使用 close() 關閉通道

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  package main import "fmt" func main() { ch := make(chan int) go func() { ch <- 1 ch <- 2 close(ch) // 關閉通道 }() for val := range ch { fmt.Println(val) // 輸出: 1 2 } }

  輸出結果：

  1 2

  1 2

  📝 使用 close() 函式能夠有效地關閉通道，並避免不必要的資源浪費。

8️⃣ 使用 panic() 觸發恐慌

panic() 函式觸發程式的異常終止，並開始錯誤處理流程。這通常在程式遇到無法繼續執行的錯誤時使用。

• 範例：使用 panic() 觸發異常

  1 2 3 4 5 6 7

  package main import "fmt" func main() { panic("程式發生錯誤，立即終止！") }

  輸出結果：

  1 2 3 4 5 6

  panic: 程式發生錯誤，立即終止！ goroutine 1 [running]: main.main() /path/to/your/file.go:4 +0x60 exit status 2

  📝 panic() 用於處理不可恢復的錯誤，並終止程式執行。

9️⃣ 使用 recover() 恢復程式

recover() 函式用來恢復程式中的恐慌，並將其轉換為正常的程式流。通常用於 defer 語句中。

• 範例：使用 recover() 恢復程式

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  package main import "fmt" func safeDivide(a, b int) int { defer func() { if r := recover(); r != nil { fmt.Println("錯誤:", r) } }() return a / b } func main() { fmt.Println(safeDivide(10, 0)) // 輸出: 錯誤: runtime error: integer divide by zero }

  📝 recover() 可以從 panic() 中恢復，使程式在錯誤發生時不會完全崩潰。

🔟 使用 print() 和 println() 輸出資訊

print() 和 println() 函式用來輸出資訊。print() 不會自動換行，而 println() 會在輸出後換行。

• 範例：使用 print() 和 println()

  1 2 3 4 5 6

  package main func main() { print("Hello, ") println("Go!") }

  輸出結果：

  1	Hello, Go!

  📝 print() 和 println() 是簡單的輸出函式，可以用來在調試時輸出資訊。

⏸️ 使用 complex()、real() 和 imag() 處理複數

Go 支援複數數字類型。complex() 函式用來創建複數，real() 和 imag() 則分別返回複數的實部和虛部。

• 範例：使用 complex()、real() 和 imag()

  1 2 3 4 5 6 7 8 9 10

  package main import "fmt" func main() { c := complex(3, 4) // 創建複數 3 + 4i fmt.Println("複數:", c) // 輸出: 3+4i fmt.Println("實部:", real(c)) // 輸出: 3 fmt.Println("虛部:", imag(c)) // 輸出: 4 }

  輸出結果：

  1 2 3

  複數: (3+4i) 實部: 3 虛部: 4

  📝 使用 complex()、real() 和 imag() 可以輕鬆處理複數數字，這對於數學運算非常有用。

🚀 內建函式的應用場景

1️⃣ 處理動態資料結構

在許多情況下，我們需要處理動態長度的資料結構。Go 的內建函式（如 append()、len()、cap()）能夠輕鬆地處理這些需求，使得資料結構的管理更加簡便。

2️⃣ 資料結構的操作與管理

如同 copy()、delete() 等函式，在處理資料結構時，Go 提供了許多內建工具來操作和管理資料，這些函式使得資料處理更加高效。

3️⃣ 提高程式效率與可讀性

Go 語言的內建函式讓我們可以用簡潔的語法完成許多複雜的操作，提升程式的效率和可讀性。善用這些函式，可以大大減少不必要的程式碼。

🎯 總結

• Go 語言提供了許多強大的內建函式，能夠幫助開發者簡化程式設計。
• len()、cap()、append()、copy()、make() 和 delete() 等函式是日常開發中常用的內建工具。
• close()、panic()、recover()、print()、println()、complex()、real() 和 imag() 函式則在處理錯誤、數學計算以及 I/O 操作等方面非常有用。
• 善用這些內建函式，可以讓我們寫出更加高效、簡潔且易讀的程式。

掌握 Go 語言中的內建函式，能讓你的程式設計更加靈活且高效。

最後建議回顧一下 Go | 菜鳥教學 目錄，了解其章節內容。

註：以上參考了
Go