Swift Academy · Aula

Subscritos e Extensões Genéricos

Aplique restrições a subscritos e extensões.

Subscritos e Extensões Genéricos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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 Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Subscritos genéricos

Os subscritos podem ser genéricos, recebendo seus próprios parâmetros de tipo, independentes do tipo que os contém. Isso permite que um único subscrito atenda a vários tipos de entrada.

struct Lookup {
    let data = [1, 2, 3, 4, 5]
    subscript<S: Sequence>(indices idx: S) -> [Int] where S.Element == Int {
        idx.map { data[$0] }
    }
}
print(Lookup()[indices: [0, 2, 4]])

Por que usar subscritos genéricos

Você pode passar um Array, um Set ou um Range de índices ao mesmo subscrito, porque ele aceita qualquer Sequence de Int.

struct Lookup {
    let data = [10, 20, 30, 40]
    subscript<S: Sequence>(_ idx: S) -> [Int] where S.Element == Int {
        idx.map { data[$0] }
    }
}
let l = Lookup()
print(l[0...1])
print(l[[3, 0]])

Extensões com restrições

Uma extension ... where adiciona membros que existem somente quando a restrição é satisfeita. Eles aparecem no tipo apenas para argumentos genéricos correspondentes.

extension Array where Element: Numeric {
    func sumAll() -> Element { reduce(0, +) }
}
print([1, 2, 3].sumAll())
print([1.5, 2.5].sumAll())

Extensão para um tipo de elemento específico

Use where Element == String para adicionar funções auxiliares específicas de String somente a vetores de strings.

extension Array where Element == String {
    func shout() -> [String] { map { $0.uppercased() + "!" } }
}
print(["hi", "bye"].shout())

Extensão com restrição de protocolo

Adicione comportamento quando os elementos estiverem em conformidade com um protocolo personalizado.

protocol Priced { var price: Double { get } }
struct Item: Priced { let price: Double }
extension Collection where Element: Priced {
    var total: Double { reduce(0) { $0 + $1.price } }
}
print([Item(price: 2), Item(price: 3)].total)

Subscrito genérico que retorna um opcional

Um subscrito pode ser genérico e retornar um opcional, por exemplo, para fazer uma indexação segura em uma coleção.

extension Array {
    subscript(safe i: Int) -> Element? {
        indices.contains(i) ? self[i] : nil
    }
}
print([1, 2, 3][safe: 1] ?? -1)
print([1, 2, 3][safe: 9] ?? -1)

Subscrito genérico em um dicionário

Os subscritos genéricos podem aceitar uma sequência de chaves e retornar os valores correspondentes.

extension Dictionary {
    subscript<S: Sequence>(keys ks: S) -> [Value] where S.Element == Key {
        ks.compactMap { self[$0] }
    }
}
let d = ["a": 1, "b": 2, "c": 3]
print(d[keys: ["a", "c"]].sorted())

Combinando com where em Self

As extensões de tipos genéricos podem restringir o tipo envolvido, expondo APIs personalizadas.

struct Stack<T> { var items: [T] = [] }
extension Stack where T: Comparable {
    var peakMax: T? { items.max() }
}
var s = Stack<Int>(); s.items = [3, 9, 1]
print(s.peakMax!)

Subscrito genérico com vários parâmetros

Um subscrito pode receber vários argumentos e seus próprios parâmetros de tipo ao mesmo tempo.

struct Grid {
    let rows = [[1, 2], [3, 4]]
    subscript(_ r: Int, _ c: Int) -> Int { rows[r][c] }
}
print(Grid()[1, 0])

Somente leitura versus leitura e gravação

Assim como as propriedades, os subscritos podem ter apenas um get ou tanto get quanto set para permitir mutações.

struct Pad {
    var values = [0, 0, 0]
    subscript(i: Int) -> Int {
        get { values[i] }
        set { values[i] = newValue }
    }
}
var p = Pad(); p[1] = 7
print(p.values)

Combinando tudo

Subscritos genéricos e extensões com restrições permitem criar APIs expressivas e seguras quanto aos tipos, que se adaptam a quaisquer tipos de elemento ou argumento utilizados.

extension Array where Element: Comparable {
    subscript(topAfterSort i: Int) -> Element { sorted()[i] }
}
print([5, 1, 9, 3][topAfterSort: 0])

Verificação rápida

Teste sua compreensão dos subscritos genéricos e das extensões com restrições.

Recapitulação

Subscritos genéricos declaram seus próprios parâmetros de tipo e cláusulas where, permitindo que um único subscrito aceite vários tipos de entrada. Extensões com restrições (where Element: ... ou == ...) adicionam membros somente quando as condições são satisfeitas. Juntos, eles criam APIs seguras quanto aos tipos e adaptáveis.

Perguntas Frequentes

A aula “Subscritos e Extensões Genéricos” é grátis?

Sim — o texto completo de “Subscritos e Extensões Genéricos” é 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 Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Subscritos e Extensões Genéricos”?

Aplique restrições a subscritos e extensões. Você pratica Swift 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 Swift Academy?

Nenhuma experiência prévia é necessária. Swift 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 4 de 4.

Quanto tempo leva a aula “Subscritos e Extensões Genéricos”?

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 Swift Academy?

Sim. Cada aula de Swift 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 Swift Academy