Go語(yǔ)言在1.18版本中引入泛型，解決了代碼復(fù)用性差的問(wèn)題，通過(guò)定義類(lèi)型參數(shù)和約束條件，使函數(shù)和數(shù)據(jù)結(jié)構(gòu)能適用於多種類(lèi)型。 1. 泛型允許使用類(lèi)型參數(shù)（如[T any]）編寫(xiě)通用函數(shù)（如Map），避免為不同類(lèi)型重複實(shí)現(xiàn)相同邏輯；2. 通過(guò)接口定義約束（如Number interface{int|float64}），控制泛型的使用範(fàn)圍，確保類(lèi)型安全；3. 簡(jiǎn)化了通用數(shù)據(jù)結(jié)構(gòu)（如Stack）的實(shí)現(xiàn)，提升編譯期類(lèi)型檢查能力，減少運(yùn)行時(shí)錯(cuò)誤；4. 使用泛型可減少冗餘代碼、提高代碼安全性與可讀性，但也存在部分庫(kù)尚未支持泛型、類(lèi)型推斷不完善及復(fù)雜約束影響可讀性的局限性?？傮w而言，泛型增強(qiáng)了Go語(yǔ)言編寫(xiě)高效、可維護(hù)代碼的能力。

Generics in Go, introduced in version 1.18, allow developers to write functions and data structures that can work with any type, as long as certain constraints are met. This feature enhances code reusability by reducing the need for redundant code that only differs in the types it operates on.

Before generics, if you wanted to implement a function like Map or Filter for different types—say, one for integers and another for strings—you had to either duplicate the logic or use interface{} with reflection, which is less safe and harder to maintain. Generics solve this problem by letting you define type parameters, similar to templates in C or generics in Java and C#.

Type Parameters Make Functions Flexible

With generics, you can define a function using a type parameter instead of a concrete type. For example:

 func Map[T any](s []T, f func(T) T) []T {
    result := make([]T, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

Here, [T any] introduces a type parameter T that can be any type. The function Map can now work on slices of any type, as long as you provide a function that matches the element type.

This avoids writing separate MapInt , MapString , etc., functions. You write it once, and it works everywhere.

Constraints Allow Controlled Flexibility

Using any gives full flexibility, but sometimes you want to restrict what types can be used. That's where constraints come in.

Go uses interfaces to define constraints. For example, if you want a generic function that only works with numeric types:

 type Number interface {
    int | float64
}

func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total = n
    }
    return total
}

In this case, Number is a constraint that allows either int or float64 . The pipe symbol ( | ) is used to list allowed types. This ensures type safety while still allowing reuse across multiple types.

You can also create more complex constraints by combining interfaces and embedding other constraints.

Generic Data Structures Are Easier to Build

Before generics, creating reusable data structures like stacks, queues, or linked lists often required using interface{} and type assertions, which could lead to runtime errors.

Now, you can define them cleanly:

 type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() T {
    n := len(s.items)
    item := s.items[n-1]
    s.items = s.items[:n-1]
    return item
}

This Stack can now safely hold any type without losing compile-time type checking.

It's much cleaner than using interface{} and avoids unnecessary boilerplate or unsafe conversions.

Practical Benefits and Limitations

Using generics in Go brings several benefits:

• Less duplication : One implementation can handle multiple types.
• Safer code : Avoids reliance on interface{} and reflection.
• Improved readability : Type relationships are clearer in function signatures.

However, there are some limitations:

• Not all existing libraries support generics yet.
• Type inference isn't perfect—it may require explicit type arguments in some cases.
• Complex constraints can get hard to read quickly.

Still, for many common tasks like utility functions, collections, and middleware, generics offer real value.

Basically, generics open up new possibilities for writing clean, efficient, and reusable code in Go. They're not a magic bullet, but when used wisely, they reduce duplication and improve maintainability without sacrificing Go's simplicity.

以上是GO中的仿製藥是什麼（在1.18中引入），它們?nèi)绾卧鰪?qiáng)代碼可重複性？的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！