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!