Gehen Sie mit Beispielgenerika

Go Generics werden seit 1.18 unterstützt und zum Schreiben von generischen Code für Typ-Safe verwendet. 1. Die generische Funktion printslice [t beliebig] (s [] t) kann Scheiben jeglicher Art drucken, z. B. [] int oder [] String. 2. Implementieren Sie durch Typ -Einschränkungsnummer t auf numerische Typen wie int und float summe [t -Nummer] (Slice [] t) T Safe Summation. A. Generisches Struktur -Typ Box [t jeder] struktur {value t} kann jeden Typ -Wert zusammenfassen und mit der NewBox [T] (V T) *Box [t] Constructor verwendet werden. 4. Set (v t) hinzufügen und () m Methoden zum Boxen [t] erhalten, ohne wiederholt [t] in die Methode zu deklarieren. 5. Die Parameterfunktion des Multi-Typs enthält einen Wert [k vergleichbar, v jeder] (M-Karte [k] v, Wert v) BOOL bestimmt, ob in der Karte ein bestimmter Wert vorhanden ist und K verglichen werden muss. 6. Praktische Anwendungen wie der allgemeine Cache-Cache [k vergleichbar, v jeder] struktur {data map [k] v}, die SET- und Erhalten von Vorgängen zum Implementieren von Typ-Safe-Schlüsselwertspeichern für den Typ. Generika verbessern die Wiederverwendbarkeit und Sicherheit von Code durch Typparameter, Einschränkungen und Gewerkschaftstypen, und die Syntax ist prägnant und praktisch.

Generika für GO wurden seit Go 1.18 offiziell unterstützt, sodass Sie gemeinsame Funktionen und Datenstrukturen schreiben können, die mehrere Typen verarbeiten können. Das Folgende sind einige typische generische Beispiele , mit denen Sie schnell verstehen können, wie Generika in der Praxis verwendet werden.

✅ 1. Generische Funktion: PrintSlice[T any]

Wenn Sie einen Slice -Inhalt drucken möchten, wie z. B. []int und []string , können Sie eine generische Funktion schreiben:

 func printslice [t irgendwelche] (s [] t) {
    Für _, v: = Bereich S {
        fmt.print (v, "")
    }
    fmt.println ()
}

// Beispiel für Printslice ([] int {1, 2, 3}) // Ausgabe: 1 2 3
Printslice ([] String {"a", "b"}) // Ausgabe: AB

• [T any] bedeutet, dass der Typparameter T von jedem Typ sein kann.
• any ist ein Alias für interface{} , die keine Einschränkungen anzeigt.

✅ 2. Generische Funktionen: Mit Typ -Einschränkungen (Einschränkung)

Wenn Sie Typen einschränken möchten, z. B. nur numerische Typen sind zulässig, können Sie Einschränkungen definieren:

 Typ number -Schnittstelle {
    int | int32 | int64 | float32 | float64
}

func sum [t nummer] (Slice [] t) t {
    var total t
    Für _, v: = Bereich Slice {
        Gesamt = v
    }
    Return Total
}

// Verwenden Sie fmt.println (sum ([] int {1, 2, 3}) // 6
fmt.println (sum ([] float64 {1.1, 2.2}) // 3.3

• Number ist ein Schnittstellentyp, der | verwendet Um Gewerkschaftstyp (Union) zu vertreten, und Limit T muss einer der aufgelisteten Typen sein.
• Dies verhindert, dass Sie string oder struct usw. nicht unterstützen Art des Betriebs.

✅ 3. Generisches Struktur

Definieren Sie einen gemeinsamen Box , der jede Art von Wert aufnehmen kann:

 Geben Sie das Box [t Any] struct {ein
    Wert t
}

func NewBox [t irgendein] (v t) *Box [t] {
    return & box [t] {value: v}
}

// Intbox: = NewBox (42) verwenden
strbox: = newbox ("Hallo")

fmt.println (intbox.value) // 42
fmt.println (strbox.value) // Hallo

• Box[T] ist eine generische Struktur.
• NewBox ist ein generischer Konstruktor, der die Typen automatisch abzieht.

✅ 4. Generische Methoden

Fügen Sie Methoden zu generischen Strukturen hinzu:

 func (b *box [t]) set (v t) {
    B. value = v
}

func (b *box [t]) get () t {
    Rückkehr B. value
}

// Box verwenden: = newbox (100)
Box.set (200)
fmt.println (box.get ()) // 200

Die Methode selbst muss [T] nicht deklarieren, da sie bereits zum Box[T] -Typ gehört.

✅ 5. Generika und Karte: Finden Sie Schlüsselwerte

Schreiben Sie eine allgemeine Funktion, um zu finden, ob in der Karte ein Wert vorhanden ist:

 func enthält sValue [k vergleichbar, v beliebig] (m map [k] v, value v) bool {
    für _, v: = Bereich m {
        Wenn v == Wert {
            RECHT WAHR
        }
    }
    Return falsch
}

// Verwenden Sie m: = map [string] int {"a": 1, "b": 2}
fmt.println (enthältValue (m, 2)) // true
fmt.println (enthält value (m, 3)) // false

• K comparable : Der Schlüsseltyp muss vergleichbar sein (z. B. Zeichenfolge, int, struktur usw.).
• V any : Der Wert kann von jedem Typ sein.
• Mehrere Typparameter werden durch Kommas getrennt.

✅ 6. Praktische Anwendungsszenarien: Allgemeiner Cache

Sie können eine einfache Cache -Struktur mit Generika implementieren:

 Geben Sie Cache [k vergleichbar, v jeder] struktur {
    Datenkarte [k] v
}

Func Newcache [K vergleichbar, v irgendwelche] () *Cache [k, v] {
    return & cache [k, v] {
        Daten: make (map [k] v),
    }
}

func (c *cache [k, v]) set (key k, value v) {
    C.Data [Schlüssel] = Wert
}

func (c *cache [k, v]) get (key k) (v, bool) {
    V, OK: = C.Data [Schlüssel]
    Rückkehr v, ok
}

verwenden:

 Cache: = newcache [String, int] ()
Cache.set ("Benutzer", 100)
If Val, OK: = cache.get ("Benutzer"); OK {
    fmt.println ("count:", val)
}

Zusammenfassung: Schlüsselpunkte der Generika

• Verwenden Sie [T any] oder [T Constraint] um Typparameter zu definieren.
• comparable ist eine vordefinierte Einschränkung für vergleichbare Typen (für Kartenschlüssel, == Urteil usw.).
• Gewerkschaftstypen ( | ) können Typensammlungen einschränken.
• Generika machen Funktionen und Strukturen allgemeiner, Typ-sicherer und reduzieren den doppelten Code.

Grundsätzlich ist das. Go Generics verfolgen keine Komplexität, sondern betonen die Praktikabilität und Klarheit. Wenn Sie es zum ersten Mal verwenden, werden Sie das Gefühl haben, dass die Grammatik etwas neu ist, aber nachdem Sie ein paar Beispiele geschrieben haben, werden Sie sich ganz natürlich fühlen.

Das obige ist der detaillierte Inhalt vonGehen Sie mit Beispielgenerika. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!