Go:
Sắp xếp mã lập trình vào trong hàm

Làm thế nào:

Trong Go, bạn định nghĩa một hàm sử dụng từ khóa func, theo sau là tên của hàm, các tham số (nếu có), và kiểu trả về. Hãy minh họa bằng một ví dụ đơn giản:

package main

import "fmt"

// định nghĩa một hàm để tính tổng hai số
func addNumbers(a int, b int) int {
    return a + b
}

func main() {
    sum := addNumbers(5, 7)
    fmt.Println("Tổng là:", sum)
    // Output: Tổng là: 12
}

Hàm cũng có thể trả về nhiều giá trị, đây là một đặc điểm khác biệt so với nhiều ngôn ngữ khác. Dưới đây là cách bạn có thể tận dụng điều này:

// định nghĩa một hàm để hoán đổi hai số
func swap(a, b int) (int, int) {
    return b, a
}

func main() {
    x, y := swap(10, 20)
    fmt.Println("x, y sau khi hoán đổi:", x, y)
    // Output: x, y sau khi hoán đổi: 20 10
}

Bạn cũng có thể định nghĩa các hàm với số lượng tham số không xác định sử dụng dấu ba chấm ... trước kiểu tham số. Điều này hữu ích cho việc tạo ra các hàm linh hoạt:

// định nghĩa một hàm để tính tổng của một số lượng không xác định số nguyên
func sum(numbers ...int) int {
    total := 0
    for _, number := range numbers {
        total += number
    }
    return total
}

func main() {
    total := sum(1, 2, 3, 4, 5)
    fmt.Println("Tổng là:", total)
    // Output: Tổng là: 15
}

Sâu hơn

Khái niệm tổ chức code thành các hàm không chỉ riêng gì Go - đó là một nguyên tắc lập trình cơ bản. Tuy nhiên, Go giới thiệu một số quy ước và khả năng nhất định làm cho quản lý hàm của nó nổi bật. Ví dụ, khả năng trả về nhiều giá trị từ các hàm là tương đối độc đáo và có thể dẫn đến việc code sạch sẽ, dễ hiểu hơn, đặc biệt khi xử lý các thao tác mà truyền thống có thể cần dùng đến con trỏ hoặc xử lý ngoại lệ.

Hơn nữa, việc Go hỗ trợ các hàm hạng nhất - các hàm có thể được truyền như là tham số cho các hàm khác, trả về như là giá trị từ các hàm và gán cho các biến - tăng cường hỗ trợ của ngôn ngữ này cho các mẫu lập trình hàm. Tính năng này đặc biệt hữu ích trong việc tạo ra các hàm cấp cao mà thao tác hoặc kết hợp các hàm khác.

Tuy nhiên, điều cần thiết là phải nhận thức về “luật của sự giảm phát sinh” khi tổ chức code thành các hàm. Việc chia nhỏ quá mức có thể dẫn đến sự trừu tượng quá mức, khiến code khó hiểu và bảo trì. Hơn nữa, trong khi cách tiếp cận đơn giản của Go đối với việc xử lý lỗi (trả lỗi như là giá trị trả về bình thường) khuyến khích việc lan truyền lỗi sạch sẽ qua nhiều lớp gọi hàm, nó có thể dẫn đến việc xử lý lỗi lặp đi lặp lại. Các giải pháp thay thế như khung xử lý lỗi hoặc áp dụng cách tiếp cận “try-catch” từ các ngôn ngữ khác (mặc dù không được hỗ trợ nguyên bản) thông qua các triển khai gói đôi khi có thể cung cấp giải pháp thanh lịch hơn tùy thuộc vào trường hợp sử dụng.

Quyết định sử dụng hàm và việc modular hóa trong Go đến mức nào nên cân nhắc giữa nhu cầu về trừu tượng hóa, khả năng bảo trì, hiệu suất và việc xử lý lỗi dễ đọc, tối đa hóa lợi ích của các tính năng đơn giản nhưng mạnh mẽ của Go.