Deeply understand the secrets of Golang function addresses

The function address is a pointer to the function code and can be obtained using unsafe.Pointer. Function addresses can be passed to other functions, such as printing function names or sorting by function. It also allows function pointer type assertions to be used to check functions that implement a specific interface.

In-depth understanding of the mystery of Go function address

Introduction
In Go, function address is a valuable tool. It allows us to pass functions by reference, giving the code greater flexibility. This article will deeply analyze the internal mechanism of function addresses and demonstrate its application through practical cases.

The essence of function address
The function address is essentially a pointer, which points to the code segment of the function in memory. Like any other pointer, it takes the form *T, where T is the function type.

Get the function address
In Go, you can use the Pointer function in the unsafe.Pointer package to get the function address:

import "unsafe"

func getFuncAddr(f func()) uintptr {
    return uintptr(unsafe.Pointer(&f))
}

getFuncAddr The function receives a function as a parameter and returns its address.

Pass function address
Function address can be passed as a parameter to other functions. For example, consider a function that prints a function name:

import "fmt"

func printFuncName(f func()) {
    fmt.Println(runtime.FuncForPC(getFuncAddr(f)).Name())
}

printFuncName takes a function and prints its name. The runtime.FuncForPC function converts a function address into its corresponding *Func value, allowing us to access the function's metadata.

Practical case
Sort slices:
We can use function addresses to perform function-based sorting of slice elements:

func sortByFunc(nums []int, compare func(a, b int) int) {
    sort.Slice(nums, func(i, j int) bool {
        return compare(nums[i], nums[j]) < 0
    })
}

func main() {
    nums := []int{5, 2, 8, 1, 9}
    sortByFunc(nums, func(a, b int) int {
        return a - b
    })
    fmt.Println(nums) // 输出： [1 2 5 8 9]
}

In this example, sortByFunc accepts a slice and a comparison function, and then uses sort.Slice to sort the slices based on the comparison function.

Function pointer type assertion:
Function pointer type assertion allows us to check whether a function pointer implements a specific interface:

import "fmt"

type Stringer interface {
    String() string
}

func isStringer(f interface{}) bool {
    _, ok := f.(func() string)
    return ok
}

func main() {
    fmt.Println(isStringer(func() string { return "Hello" })) // true
    fmt.Println(isStringer(func() int { return 1 }))           // false
}

isStringer Function checks whether the given interface value implements the Stringer interface. It uses type assertions to determine whether the interface value points to a function that implements the String() method.

The above is the detailed content of Deeply understand the secrets of Golang function addresses. For more information, please follow other related articles on the PHP Chinese website!