Swift Academy · Aula

Cláusulas where em Funções

Adicione restrições detalhadas a funções genéricas.

Cláusulas where em Funções é uma aula grátis de Swift 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 Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Além das restrições simples

Uma restrição como <T: Collection> descreve o próprio T. Porém, às vezes é necessário restringir os tipos associados de T, como seu Element. É isso que uma cláusula where faz.

func sumInts<C: Collection>(_ c: C) -> Int where C.Element == Int {
    c.reduce(0, +)
}
print(sumInts([1, 2, 3]))

Requisito de mesmo tipo

where C.Element == Int exige que os elementos da coleção sejam exatamente Int, permitindo operações específicas com inteiros.

func describe<C: Collection>(_ c: C) -> String where C.Element == Int {
    "Sum is " + String(c.reduce(0, +))
}
print(describe(Set([1, 2, 3])))

Requisito de protocolo no elemento

Você pode exigir que o elemento esteja em conformidade com um protocolo, em vez de exigir um único tipo exato, o que oferece mais flexibilidade.

func joinAll<C: Collection>(_ c: C) -> String
    where C.Element: CustomStringConvertible {
    c.map { $0.description }.joined(separator: ", ")
}
print(joinAll([1, 2, 3]))

where vem depois da assinatura

A cláusula where fica entre o tipo de retorno e o corpo da função. As restrições dentro de <> e a cláusula where funcionam em conjunto.

func maxElement<C: Collection>(_ c: C) -> C.Element?
    where C.Element: Comparable {
    c.max()
}
print(maxElement([4, 9, 2])!)

Relacionando dois parâmetros de tipo

Uma cláusula where pode relacionar os tipos de elemento de dois genéricos diferentes usando ==.

func combine<A: Collection, B: Collection>(_ a: A, _ b: B) -> [A.Element]
    where A.Element == B.Element {
    Array(a) + Array(b)
}
print(combine([1, 2], Set([3])))

Várias condições where

Liste vários requisitos separados por vírgulas para expressar restrições compostas.

func report<C: Collection>(_ c: C)
    where C.Element: Comparable, C.Element: CustomStringConvertible {
    if let m = c.max() { print("max:", m.description) }
}
report([5, 1, 9])

Restringindo tipos associados aninhados

Você pode ir mais fundo, exigindo, por exemplo, o tipo do elemento de um elemento ao trabalhar com coleções aninhadas.

func flatten<C: Collection>(_ c: C) -> [Int]
    where C.Element: Collection, C.Element.Element == Int {
    c.flatMap { Array($0) }
}
print(flatten([[1, 2], [3]]))

where com elementos Equatable

Exigir elementos Equatable permite pesquisar uma coleção genérica.

func indexOf<C: Collection>(_ x: C.Element, in c: C) -> C.Index?
    where C.Element: Equatable {
    c.firstIndex(of: x)
}
if let i = indexOf(2, in: [1, 2, 3]) { print("found") }

Métodos genéricos com where

Os métodos dentro de tipos genéricos também usam where, geralmente para adicionar comportamento somente a determinados tipos de elemento.

struct Wrap<T> {
    let items: [T]
    func total() -> Int where T == Int { items.reduce(0, +) }
}
print(Wrap(items: [1, 2, 3]).total())

Benefício de legibilidade

Restrições complexas ficam mais claras em uma cláusula where do que amontoadas entre os colchetes angulares, especialmente quando há várias condições de tipos associados.

func first<C: Collection>(_ c: C) -> String
    where C.Element: CustomStringConvertible {
    c.first.map { $0.description } ?? "empty"
}
print(first([10, 20]))

where na biblioteca padrão

Métodos como joined() em sequências de sequências usam cláusulas where internamente para expressar seus requisitos com precisão.

let nested = [[1, 2], [3, 4]]
print(Array(nested.joined()))

Verificação rápida

Teste sua compreensão das cláusulas where em funções.

Recapitulação

As cláusulas where permitem restringir os tipos associados de um genérico: exigir que um elemento seja de um tipo específico (== Int), esteja em conformidade com um protocolo (: Comparable), relacionar os elementos de dois parâmetros ou acessar tipos associados aninhados. Elas aparecem depois da assinatura e mantêm claras as restrições complexas.

Perguntas Frequentes

A aula “Cláusulas where em Funções” é grátis?

Sim — o texto completo de “Cláusulas where em Funções” é 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 “Cláusulas where em Funções”?

Adicione restrições detalhadas a funções genéricas. 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 2 de 4.

Quanto tempo leva a aula “Cláusulas where em Funções”?

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