Like Share Discussion Bookmark Smile

J.J. Huang   2025-03-09   Getting Started Golang 04.函式   瀏覽次數:次   DMCA.com Protection Status

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