0Pricing
Swift Academy · Aula

Funções e tipos genéricos

Escreva funções e tipos genéricos com parâmetros de tipo (por exemplo, ). Veja como o compilador infere os tipos e mantém o código seguro e reutilizável.

Funções e tipos genéricos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 3. 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 3 aulas no total.

Por que usar genéricos?

Os genéricos permitem escrever uma única função ou tipo que funciona com muitos tipos, mantendo a segurança de tipos. Você verá <T> para parâmetros de tipo e como a inferência torna as chamadas simples.

Função genérica

Uma função genérica usa um parâmetro de tipo (<T>). O compilador verifica os tipos em cada chamada.

// Generic swap for any type T
func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 1, y = 2
swapValues(&x, &y)
print(x, y)  // 2 1

var s1 = "A", s2 = "B"
swapValues(&s1, &s2)
print(s1, s2) // B A

Tipo genérico

Os tipos também podem ser genéricos: declare Stack e reutilize-o para tipos inteiros, de texto e muitos outros.

// A minimal generic stack
struct Stack<Element> {
    private var items: [Element] = []
    mutating func push(_ x: Element) { items.append(x) }
    mutating func pop() -> Element? { items.popLast() }
    var top: Element? { items.last }
}

var intStack = Stack<Int>()
intStack.push(10); intStack.push(20)
print(intStack.top ?? -1)   // 20

var textStack = Stack<String>()
textStack.push("hi"); textStack.push("bye")
print(textStack.pop() ?? "?")

Inferência de tipos

O Swift frequentemente infere os tipos genéricos, portanto raramente você precisa especificá-los explicitamente nas chamadas.

// The compiler infers T from arguments/assignments
func makePair<T>(_ a: T, _ b: T) -> (T, T) { (a, b) }

let pair1 = makePair(1, 2)          // T inferred as Int
let pair2 = makePair("a", "b")      // T inferred as String
print(pair1, pair2)

Evitar duplicação

Sem genéricos, você repetiria o código para cada tipo. Os genéricos eliminam a duplicação enquanto mantêm as verificações estáticas.

// Non-generic overloads would duplicate logic:
func eqInt(_ a: Int, _ b: Int) -> Bool { a == b }
func eqStr(_ a: String, _ b: String) -> Bool { a == b }
// A single generic can replace both:

Observações e nomenclatura

Observações:

  • Use nomes claros: T, Elemento ou nomes específicos do domínio.
  • Mantenha as APIs pequenas e focadas.
  • A seguir: adicione restrições com condições para limitar T quando necessário.

Significado de <T>

Verificação rápida: o que significa <T> em uma função genérica?

Recapitulação

Recapitulação: defina funções genéricas com <T> e crie tipos genéricos, como Stack. O Swift infere os tipos nas chamadas, mantendo o código reutilizável e seguro.

Perguntas Frequentes

A aula “Funções e tipos genéricos” é grátis?

Sim — o texto completo de “Funções e tipos 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 3 aulas no total.

O que vou aprender em “Funções e tipos genéricos”?

Escreva funções e tipos genéricos com parâmetros de tipo (por exemplo, ). Veja como o compilador infere os tipos e mantém o código seguro e reutilizável. 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 1 de 3.

Quanto tempo leva a aula “Funções e tipos 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

  1. Funções e tipos genéricos
  2. Restrições (where) e inferência de tipos
  3. Algoritmos genéricos em coleções
← Voltar para Swift Academy