Go Academy · Aula

Restrições: comparable e interfaces

Restrições de união e o tipo integrado comparable

Restrições: comparable e interfaces é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O que é uma restrição?

Uma restrição limita quais tipos podem ser utilizados como argumento de tipo. Sem uma restrição, o parâmetro de tipo é any (a interface vazia — ela só permite atribuição e comparação por meio de ==).

A restrição any

any (alias de interface{}) é a restrição mais abrangente — todos os tipos a satisfazem. Você só pode utilizar operações que todos os tipos suportam: atribuição e passagem para parâmetros de interface.

func Print[T any](v T) { fmt.Println(v) }

A restrição comparable

comparable restringe o parâmetro de tipo a tipos que suportam == e !=. Ela é necessária para utilizar o tipo como chave de um mapa ou em verificações de igualdade.

func Contains[T comparable](s []T, v T) bool {
    for _, item := range s {
        if item == v { return true }
    }
    return false
}

Restrições de interface

Utilize uma interface como restrição para exigir métodos específicos. O parâmetro de tipo deve ter todos os métodos da interface.

type Stringer interface { String() string }

func Print[T Stringer](v T) {
    fmt.Println(v.String())
}

Restrições de união

Utilize uma união de tipos com | para restringir o conjunto de tipos concretos permitidos. Isso permite utilizar operadores (como +) que não fazem parte de nenhuma interface.

type Number interface {
    int | int64 | float64
}

func Sum[T Number](s []T) T {
    var total T
    for _, v := range s { total += v }
    return total
}

~T para tipos subjacentes

Use ~T para incluir não apenas T, mas todos os tipos que tenham T como tipo subjacente (por exemplo, tipos personalizados definidos como type MyInt int).

type Integer interface { ~int | ~int64 }

type MyInt int
// MyInt satisfies Integer because its underlying type is int

golang.org/x/exp/constraints

O pacote constraints fornece interfaces de restrição comuns: Ordered (suporta <), Integer, Float, Signed, Unsigned.

import "golang.org/x/exp/constraints"

func Min[T constraints.Ordered](a, b T) T {
    if a < b { return a }
    return b
}

Pacote cmp (Go 1.21)

O Go 1.21 adicionou a restrição cmp.Ordered e as funções cmp.Compare/cmp.Less à biblioteca padrão, substituindo a dependência exp/constraints.

import "cmp"
func Min[T cmp.Ordered](a, b T) T { return min(a, b) }

Combinando restrições

Incorpore várias interfaces em uma restrição para exigir várias propriedades:

type Printable interface {
    comparable
    fmt.Stringer
}

Inferência de restrições

O compilador infere os parâmetros de tipo a partir dos argumentos. Se a restrição for ampla demais (any), talvez seja necessário especificar explicitamente os argumentos de tipo para orientar a inferência.

Quando usar comparable

Use comparable quando a função genérica precisar usar == nos valores, armazená-los em mapas como chaves ou usá-los como elementos de mapas/conjuntos. Nem todos os tipos são comparáveis (fatias, mapas e funções não são).

Verificação rápida

O que significa o prefixo ~ em uma restrição de união como ~int?

Recapitulação: restrições

Pontos principais:

any: mais amplo; comparable: oferece suporte a ==; interface: exige métodos
A união (int|float64) permite operadores aritméticos
~T inclui tipos nomeados que têm T como tipo subjacente
cmp.Ordered (Go 1.21+) para restrições com <, >, <=, >=

Perguntas Frequentes

A aula “Restrições: comparable e interfaces” é grátis?

Sim — o texto completo de “Restrições: comparable e interfaces” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Restrições: comparable e interfaces”?

Restrições de união e o tipo integrado comparable Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Restrições: comparable e interfaces”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy