Docs ejecutables de Go: Sets

Q: ¿Debo usar map[T]bool o map[T]struct{} para un set en Go?

map[T]struct{} deja clara la intención y sus valores ocupan cero bytes. map[T]bool se lee de forma más natural (if seen[x]) porque una clave ausente devuelve false. Los dos son correctos; la diferencia de memoria solo importa en sets muy grandes. Elige uno y sé coherente.

El idioma: un map con valores vacíos

Go no tiene la palabra clave set ni un set en la librería estándar. Un map cuyas claves son los elementos y cuyos valores no llevan nada hace el trabajo.

package main

import "fmt"

func main() {
	tags := map[string]struct{}{}

	// add
	tags["go"] = struct{}{}
	tags["backend"] = struct{}{}
	tags["go"] = struct{}{} // adding again changes nothing

	// has
	_, ok := tags["go"]
	fmt.Println("has go:", ok)

	// remove
	delete(tags, "backend")

	// size
	fmt.Println("size:", len(tags))

	for t := range tags {
		fmt.Println("member:", t)
	}
}

struct{} es el tipo struct vacío y struct{}{} es su único valor. Ocupa cero bytes, así que el map guarda las claves y nada más.

Se aplican todas las reglas de los maps: las claves tienen que ser comparables, el orden de iteración es aleatorio, un map nil provoca un panic al escribir y las escrituras concurrentes necesitan un lock. La página de maps las explica una a una.

map[T]struct{} o map[T]bool

La otra forma habitual es map[T]bool. Se lee mejor porque una clave ausente devuelve false:

seen := map[string]bool{}
seen["a"] = true
if seen["a"] { ... }

Las contrapartidas:

	`map[T]struct{}`	`map[T]bool`
Tamaño del valor	0 bytes	1 byte (más alineación)
Comprobar pertenencia	`_, ok := s[k]`	`s[k]`
Ambigüedad	ninguna	`s[k] = false` es un tercer estado

La tercera fila es el verdadero motivo por el que muchas bases de código prefieren el struct vacío: con bool, alguien acaba escribiendo s[k] = false y len(s) deja de ser el número de miembros. En sets pequeños la diferencia de memoria no importa.

Eliminar duplicados de un slice

El uso más común de un set es quitar duplicados. Esto conserva la primera aparición de cada valor y mantiene el orden:

package main

import (
	"fmt"
	"slices"
)

func unique[T comparable](in []T) []T {
	seen := make(map[T]struct{}, len(in))
	out := make([]T, 0, len(in))
	for _, v := range in {
		if _, ok := seen[v]; ok {
			continue
		}
		seen[v] = struct{}{}
		out = append(out, v)
	}
	return out
}

func main() {
	fmt.Println(unique([]string{"b", "a", "b", "c", "a"}))
	fmt.Println(unique([]int{3, 1, 3, 3, 2}))

	// If order does not matter: sort, then drop adjacent duplicates.
	s := []int{3, 1, 3, 3, 2}
	slices.Sort(s)
	fmt.Println(slices.Compact(s))
}

Salida:

[b a c]
[3 1 2]
[1 2 3]

Unión, intersección y diferencia

El álgebra de conjuntos son unos pocos bucles. Recorre el set más pequeño al comprobar la pertenencia en el otro, porque cada búsqueda tarda un tiempo constante de media.

package main

import (
	"fmt"
	"maps"
	"slices"
)

type set map[string]struct{}

func of(items ...string) set {
	s := make(set, len(items))
	for _, it := range items {
		s[it] = struct{}{}
	}
	return s
}

func union(a, b set) set {
	out := maps.Clone(a)
	for k := range b {
		out[k] = struct{}{}
	}
	return out
}

func intersect(a, b set) set {
	if len(a) > len(b) {
		a, b = b, a
	}
	out := set{}
	for k := range a {
		if _, ok := b[k]; ok {
			out[k] = struct{}{}
		}
	}
	return out
}

func difference(a, b set) set {
	out := set{}
	for k := range a {
		if _, ok := b[k]; !ok {
			out[k] = struct{}{}
		}
	}
	return out
}

func sorted(s set) []string {
	return slices.Sorted(maps.Keys(s))
}

func main() {
	backend := of("go", "sql", "docker", "linux")
	devops := of("docker", "linux", "terraform")

	fmt.Println("union:     ", sorted(union(backend, devops)))
	fmt.Println("intersect: ", sorted(intersect(backend, devops)))
	fmt.Println("backend-only:", sorted(difference(backend, devops)))
}

sorted existe solo para que la salida sea estable. Imprimir un set recorriéndolo da un orden distinto en cada ejecución. maps.Keys y slices.Sorted necesitan Go 1.23.

Un tipo con nombre como type set map[string]struct{} sigue siendo un map: lo indexas, lo recorres con range y haces delete de la misma forma, y puedes colgarle métodos.

Un pequeño Set genérico

Con genéricos (Go 1.18), un solo tipo sirve para cualquier tipo de elemento comparable. Esto basta para la mayoría de programas:

package main

import (
	"cmp"
	"fmt"
	"maps"
	"slices"
)

type Set[T comparable] struct {
	m map[T]struct{}
}

func NewSet[T comparable](items ...T) *Set[T] {
	s := &Set[T]{m: make(map[T]struct{}, len(items))}
	for _, it := range items {
		s.Add(it)
	}
	return s
}

func (s *Set[T]) Add(v T)    { s.m[v] = struct{}{} }
func (s *Set[T]) Remove(v T) { delete(s.m, v) }
func (s *Set[T]) Len() int   { return len(s.m) }
func (s *Set[T]) Has(v T) bool {
	_, ok := s.m[v]
	return ok
}

func (s *Set[T]) Union(o *Set[T]) *Set[T] {
	out := &Set[T]{m: maps.Clone(s.m)}
	for v := range o.m {
		out.Add(v)
	}
	return out
}

// Sorted is a free function because it needs a stricter constraint than the type.
func Sorted[T cmp.Ordered](s *Set[T]) []T {
	return slices.Sorted(maps.Keys(s.m))
}

func main() {
	a := NewSet(1, 2, 3)
	b := NewSet(3, 4)
	a.Add(2)
	fmt.Println(a.Len(), a.Has(2), a.Has(9))

	u := a.Union(b)
	fmt.Println(Sorted(u))

	words := NewSet("go", "rust")
	words.Remove("rust")
	fmt.Println(Sorted(words))
}

Envolver el map en un struct esconde el ruido de struct{}{} y garantiza que el constructor crea el map, lo que elimina el panic del map nil. Sorted no puede ser un método: un método no puede declarar sus propios parámetros de tipo ni endurecer la restricción comparable del tipo, y ordenar necesita cmp.Ordered. La página de genéricos explica las restricciones.

Si necesitas un set completo (variantes seguras para concurrencia, muchas operaciones), existen paquetes de terceros como github.com/deckarep/golang-set. Para la mayor parte del código, el idioma del map o un tipo de 30 líneas como este es lo que usan los programadores de Go.

Sets de structs

Cualquier tipo comparable puede ser un elemento, incluidos los structs con campos comparables. Eso hace directas las comprobaciones de "¿he visto ya este par?":

type edge struct{ from, to string }
visited := map[edge]struct{}{}
visited[edge{"a", "b"}] = struct{}{}

Los slices y los maps no pueden ser elementos de un set. Para registrar slices únicos, convierte antes cada uno en una clave comparable, por ejemplo un array de tamaño fijo o un string construido con fmt.Sprint.

Errores comunes

Olvidar inicializar. var s map[string]struct{} es nil; la primera inserción provoca un panic.
Imprimir un set y esperar una salida estable. Ordena antes los miembros.
Usar map[T]bool y guardar false. Entonces len ya no cuenta los miembros. Usa delete para quitar.

Preguntas frecuentes

¿Tiene Go un tipo set?

No. La librería estándar no tiene sets. El idioma es un map cuyos valores no aportan información: map[string]struct{}. Añadir es s[k] = struct{}{}, comprobar la pertenencia es _, ok := s[k], quitar es delete(s, k) y el tamaño es len(s).

¿Debo usar map[T]bool o map[T]struct{} para un set en Go?

map[T]struct{} deja clara la intención y sus valores ocupan cero bytes. map[T]bool se lee de forma más natural (if seen[x]) porque una clave ausente devuelve false. Los dos son correctos; la diferencia de memoria solo importa en sets muy grandes. Elige uno y sé coherente.

¿Cómo elimino los duplicados de un slice en Go?

Para conservar la primera aparición y el orden, recorre el slice apuntando los valores vistos en un map[T]struct{} y añade solo los que no has visto. Si el orden no importa, ordena y quita los duplicados contiguos: slices.Sort(s); s = slices.Compact(s).

Conceptos relacionados