Wide application of golang function types

The function type in the Go language allows functions to be passed as parameters or return values ​​to achieve flexible code. It includes: function type declaration: func(*argTypes) returnType passing function as parameter: passing function type as parameter of other function, passing behavior. Use function types as return values: Return function types to increase code flexibility. Practical case: Implement a sortable interface and use function types to customize sorting behavior.

Go language function type: widely used

In the Go language, the function type is a powerful tool that allows functions to be used as functions of other functions. Parameters or return values. This flexibility makes it possible to create flexible and modular code.

Declaration of function types

The declaration of function types follows the following syntax:

func(*argTypes) returnType

Where:

• *argTypes is a tuple of function parameter types.
• returnType is the function return value type, which can be any type, including other function types.

Passing functions as arguments

Function types can be passed as arguments to other functions, allowing behaviors to be passed as arguments. For example:

func apply(op func(int) int, nums []int) []int {
    result := make([]int, len(nums))
    for i, n := range nums {
        result[i] = op(n)
    }
    return result
}

apply The function accepts two parameters:

• op: a function type that accepts an int parameters and returns an int value.
• nums: A slice of type int.

It returns a new slice where each element is the result of applying op on the corresponding element in nums.

Use function types as return values

Function types can also be used as return values ​​of other functions. This allows behavior to be returned from functions, thereby increasing code flexibility. For example:

func getPredicate(n int) func(int) bool {
    return func(x int) bool {
        return x > n
    }
}

getPredicate The function returns a function type that accepts an int parameter and returns a Boolean value. The n value passed in is used to determine the behavior of the function that returns a value.

Practical case

Implementing a sortable interface

The following is an example of using a function type to implement a sortable interface:

type Person struct {
    Name string
    Age  int
}

type Sorter func([]Person)

func (s Sorter) Sort(p []Person) {
    // Implement sorting logic.
}

func main() {
    people := []Person{
        {"Alice", 20},
        {"Bob", 25},
        {"Charlie", 30},
    }
    Sort(func(p []Person) {
        sort.Slice(p, func(i, j int) bool {
            return p[i].Name < p[j].Name
        })
    })(people)
}

In this example, the Person type implements the Sorter interface, which accepts a Person slice and sorts it. The Sort function accepts a function of type Sorter as argument and performs a sort operation on the people slice.

Conclusion

The Go language's function types are a powerful tool that allow the creation of flexible and modular code. By passing functions as parameters and return values, developers can create custom behaviors and simplify code.

The above is the detailed content of Wide application of golang function types. For more information, please follow other related articles on the PHP Chinese website!