Passez par l'exemple des génériques

Les génériques GO sont pris en charge depuis 1.18 et sont utilisés pour écrire du code générique pour le type de type. 1. La fonction générique imprimslice [t any] (s [] t) peut imprimer des tranches de tout type, telles que [] int ou [] chaîne. 2. Grâce au nombre de contraintes de type, les limites des types numériques tels que INT et Float, implémentez SUM [Number] (Slice [] T) T Sommation sûre. 3. Box de type de structure générique [t any] struct {valeur t} peut encapsuler n'importe quelle valeur de type et être utilisé avec le constructeur newbox [t any] (v t) * Box [t]. 4. Ajouter des méthodes set (v t) et get () t pour boxer [t], sans déclarer à plusieurs reprises [t] dans la méthode. 5. Fonction de paramètre multi-type contient la valeur [k comparable, v any] (m map [k] v, valeur v) bool détermine s'il y a une certaine valeur dans la carte et k doit être comparée. 6. Applications pratiques telles que le cache de type cache général [k comparable, v any] struct {data map [k] v}, fournissant des opérations et obtenez des opérations pour implémenter le stockage de valeurs de clé de type type. Les génériques améliorent la réutilisabilité du code et la sécurité par le biais de paramètres de type, de contraintes et de types d'union, et la syntaxe est concise et pratique.

Les génériques pour GO ont été officiellement pris en charge depuis GO 1.18, ce qui vous permet d'écrire des fonctions et des structures de données communes qui peuvent gérer plusieurs types. Voici plusieurs exemples génériques GO typiques pour vous aider à comprendre rapidement comment utiliser les génériques dans la pratique.

✅ 1. Fonction générique: PrintSlice[T any]

Si vous souhaitez imprimer n'importe quel type de contenu Slice, tel que []int et []string , vous pouvez écrire une fonction générique:

 func impriméslice [t any] (s [] t) {
    pour _, v: = range s {
        fmt.print (v, "")
    }
    fmt.println ()
}

// Utilisez l'exemple imprimés ([] int {1, 2, 3}) // sortie: 1 2 3
PRINTSLICE ([] String {"A", "B"}) // OUTPUT: AB

• [T any] signifie que le paramètre de type T peut être de n'importe quel type.
• any est un alias pour interface{} , n'informant aucune contrainte.

✅ 2. Fonctions génériques: avec des contraintes de type (contrainte)

Si vous souhaitez restreindre les types, tels que seuls les types numériques sont autorisés, vous pouvez définir les contraintes:

 Type d'interface numéro {
    int | INT32 | INT64 | float32 | float64
}

func sum [t numéro] (tranche [] t) t {
    var total t
    pour _, v: = range tranche {
        Total = V
    }
    Retour total
}

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

• Number est un type d'interface, qui utilise | pour représenter le type syndical (syndicat), et la limite T doit être l'un des types énumérés.
• Cela vous empêche de passer string ou struct , etc. Type de fonctionnement.

✅ 3. Structure générique

Définissez un conteneur Box commun qui peut contenir tout type de valeur:

 Type Box [t any] struct {
    Valeur t
}

func newbox [t any] (v t) * box [t] {
    return & box [t] {valeur: v}
}

// Utilisez INTBOX: = NewBox (42)
strBox: = newbox ("bonjour")

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

• Box[T] est une structure générique.
• NewBox est un constructeur générique qui déduit automatiquement les types.

✅ 4. Méthodes génériques

Ajouter des méthodes aux structures génériques:

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

func (b * box [t]) get () t {
    retour b.value
}

// Utilisez la boîte: = Newbox (100)
Box.Set (200)
fmt.println (box.get ()) // 200

La méthode elle-même n'a pas besoin de déclarer [T] car elle appartient déjà Box[T] .

✅ 5. GÉNÉRIQUES ET MAP: Trouvez des valeurs clés

Écrivez une fonction générale pour trouver si une valeur existe sur la carte:

 func contientValue [k comparable, v any] (m map [k] v, valeur v) bool {
    pour _, v: = range m {
        Si v == valeur {
            Retour vrai
        }
    }
    retourner faux
}

// utilise m: = map [string] int {"a": 1, "b": 2}
fmt.println (contientValue (m, 2)) // true
fmt.println (contientValue (m, 3)) // false

• K comparable : le type de clé doit être comparable (comme la chaîne, l'int, la structure, etc.).
• V any : la valeur peut être de n'importe quel type.
• Les paramètres de type multiple sont séparés par des virgules.

✅ 6. Scénarios d'application pratiques: cache général

Vous pouvez implémenter une structure de cache simple à l'aide de génériques:

 type cache [k comparable, v any] struct {
    Carte de données [K] V
}

func newcache [k comparable, v any] () * cache [k, v] {
    return & cache [k, v] {
        Données: faire (map [k] v),
    }
}

func (c * cache [k, v]) set (key k, valeur v) {
    c.data [clé] = valeur
}

func (c * cache [k, v]) get (key k) (v, bool) {
    v, ok: = c.data [clé]
    Retour V, ok
}

utiliser:

 cache: = newCache [String, int] ()
cache.set ("utilisateurs", 100)
Si val, ok: = cache.get ("utilisateurs"); d'accord {
    fmt.println ("Count:", Val)
}

Résumé: points clés des génériques

• Utilisez [T any] ou [T Constraint] pour définir les paramètres de type.
• comparable est une contrainte prédéfinie pour les types comparables (pour la clé de carte, == jugement, etc.).
• Les types d'union ( | ) peuvent restreindre les collections de types.
• Les génériques rendent les fonctions et les structures plus générales, de type type et réduisent le code en double.

Fondamentalement, c'est tout. Les génériques ne poursuivent pas la complexité, mais ne mettent pas l'accent sur le praticité et la clarté. Lorsque vous l'utilisez pour la première fois, vous sentirez que la grammaire est un peu nouvelle, mais après avoir écrit quelques exemples, vous vous sentirez assez naturel.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!