Le langage Go a-t-il une collection définie ?

Le langage Go n'a pas de collection définie. Set est un ensemble, et les éléments de l'ensemble ne peuvent pas être répétés ; il n'y a pas d'opération sur set dans la bibliothèque standard de golang, mais il existe deux méthodes d'implémentation : 1. Utilisez l'implémentation de la carte, la clé dans la carte est une valeur unique, qui est cohérent avec les caractéristiques de set ;2. Utilisez le package golang-set pour l'implémenter.

L'environnement d'exploitation de ce tutoriel : système Windows 10, GO 1.11.2, ordinateur Dell G3.

Go ne fournit pas le type Set. Set est une collection et les éléments de l'ensemble ne peuvent pas être répétés. Mais vous pouvez utiliser deux méthodes pour définir la collection :

• map

• golang-set

Utiliser map pour implémenter

Dans Golang, map est généralement utilisé pour implémenter set. La clé dans map est une valeur unique, qui est cohérente avec les caractéristiques de. ensemble.

Une implémentation simple, comme suit :

set := make(map[string]bool) // New empty set
set["Foo"] = true            // Add
for k := range set {         // Loop
    fmt.Println(k)
}
delete(set, "Foo")    // Delete
size := len(set)      // Size
exists := set["Foo"]  // Membership

La valeur de map est booléenne, ce qui fera que set occupera plus d'espace mémoire. Pour résoudre ce problème, vous pouvez le remplacer par une structure vide. . Dans Go, les structures vides n'utilisent généralement pas de mémoire.

unsafe.Sizeof(struct{}{}) // 结果为 0

Après optimisation, c'est le suivant :

type void struct{}
var member void

set := make(map[string]void) // New empty set
set["Foo"] = member          // Add
for k := range set {         // Loop
    fmt.Println(k)
}
delete(set, "Foo")      // Delete
size := len(set)        // Size
_, exists := set["Foo"] // Membership

golang-set

golang-set-Un ensemble simple tapez pour le langage Go. Également utilisé par Docker, 1Password, Ethereum.

Il existe déjà un package mature sur github appelé golang-set, qui fournit des ensembles thread-safe et non thread-safe. Cinq fonctions définies sont fournies :

// NewSet创建并返回空集的引用，结果集上的操作是线程安全的
func NewSet(s ...interface{}) Set {}
// NewSetFromSlice从现有切片创建并返回集合的引用，结果集上的操作是线程安全的
func NewSetFromSlice(s []interface{}) Set {}
// NewSetWith创建并返回具有给定元素的新集合，结果集上的操作是线程安全的
func NewSetWith(elts ...interface{}) Set {}
// NewThreadUnsafeSet创建并返回对空集的引用，结果集上的操作是非线程安全的
func NewThreadUnsafeSet() Set {}
// NewThreadUnsafeSetFromSlice创建并返回对现有切片中集合的引用，结果集上的操作是非线程安全的。
func NewThreadUnsafeSetFromSlice(s []interface{}) Set {}

Cas simple, comme suit :

package main
import (
    "fmt"
    "github.com/deckarep/golang-set"
)
func main() {
    // 默认创建的线程安全的，如果无需线程安全
    // 可以使用 NewThreadUnsafeSet 创建，使用方法都是一样的。
    s1 := mapset.NewSet(1, 2, 3, 4)
    fmt.Println("s1 contains 3: ", s1.Contains(3))
    fmt.Println("s1 contains 5: ", s1.Contains(5))
    // interface 参数，可以传递任意类型
    s1.Add("poloxue")
    fmt.Println("s1 contains poloxue: ", s1.Contains("poloxue"))
    s1.Remove(3)
    fmt.Println("s1 contains 3: ", s1.Contains(3))
    s2 := mapset.NewSet(1, 3, 4, 5)
    // 并集
    fmt.Println(s1.Union(s2))
}

Le résultat est :

s1 contains 3:  true
s1 contains 5:  false
s1 contains poloxue:  true
s1 contains 3:  false
Set{1, 2, 4, poloxue, 3, 5}

Apprentissage recommandé : Tutoriel Golang

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!