Understanding Golang generics from scratch

Golang is an open source programming language designed and developed by Google and first released in 2009. As a modern language, Golang has always been loved by developers for its simplicity and efficiency. However, until recently, Golang has been criticized for its lack of generics support. Generics are a feature of a programming language that enable writing generic code to support different types of data.

In the Golang community, there has been controversy over when Golang will implement generic functionality. Until Go 1.18 version (released in March 2021), Golang officially announced that it officially supports generic functions. This also means that Golang has taken a big step towards generics, making it easier for developers to write more flexible and versatile code.

To understand Golang’s generic features, we need to start from scratch. First, we need to understand how to define generic functions and data structures in Golang. The following is a simple example that shows how to use generic functions to implement a slice element search function:

package main

import (
    "fmt"
)

// Generic function: find elements in a slice
func findElement[T comparable](slice []T, element T) bool {
    for _, v := range slice {
        if v == element {
            return true
        }
    }
    return false
}

func main() {
    intSlice := []int{1, 2, 3, 4, 5}
    strSlice := []string{"apple", "banana", "cherry"}

    // Call the generic function to find the element
    fmt.Println(findElement(intSlice, 3)) // true
    fmt.Println(findElement(strSlice, "pear")) // false
}

In the above code, we define a generic function findElement, use the generic type parameter T, and use the constraint comparable Ensure that the type passed in supports comparison operations. In the main function, we defined a intSlice and strSlice, and called the findElement function respectively to find elements. It can be seen that through generic functions, we can write code suitable for different types of data structures at once, which improves the reusability of the code.

In addition to generic functions, Golang's generics also support generic data structures. The following is a simple example that shows how to use generic slices to implement a stack data structure:

package main

import "fmt"

// Generic type: stack
type Stack[T any] []T

//Push to stack
func (s *Stack[T]) Push(value T) {
    *s = append(*s, value)
}

// pop off the stack
func (s *Stack[T]) Pop() T {
    if len(*s) == 0 {
        panic("stack is empty")
    }
    value := (*s)[len(*s)-1]
    *s = (*s)[:len(*s)-1]
    return value
}

func main() {
    var intStackStack[int]

    //Push to stack
    intStack.Push(1)
    intStack.Push(2)
    intStack.Push(3)

    // pop off the stack
    fmt.Println(intStack.Pop()) // 3
    fmt.Println(intStack.Pop()) // 2
}

In the above code, we define a generic type Stack[T any] to represent the stack data structure, and also define the push into the stack Push and the out StackPop method. In the main function, we create an intStack instance and perform push and pop operations on it. Through generic data structures, we can define a general stack data structure like the above example, and can support different types of elements at the same time.

Through the above two examples, we have a preliminary understanding of how to use generic features in Golang. In Golang's generic implementation, in addition to the generic functions and generic data structures shown in the example, it also supports features such as generic interfaces and generic type constraints. Developers can choose appropriate features to implement generics based on specific needs. code.

In general, Golang's generic function provides developers with more powerful programming capabilities, making the code more flexible and versatile. Although Golang's generic function was launched relatively late, it is powerful and easy to use, and can help developers write universal code more efficiently. I hope this article can help readers better understand the generic features of Golang and how to write generic code from scratch.

The above is the detailed content of Understanding Golang generics from scratch. For more information, please follow other related articles on the PHP Chinese website!