Swift Academy · Aula

Reflexão com Mirror

Inspecione as propriedades de qualquer valor em tempo de execução.

Reflexão com Mirror é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 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.

O que é Mirror?

Mirror é o recurso de reflexão em tempo de execução do Swift: ele permite inspecionar a estrutura de um valor — suas propriedades e seus valores — sem conhecer o tipo concreto em tempo de compilação.

Criando um Mirror

Passe qualquer valor para Mirror(reflecting:):

struct Point { let x: Int; let y: Int }
let m = Mirror(reflecting: Point(x: 1, y: 2))
print(m.children.count)  // 2

Iterando pelos filhos

Cada filho é um par de rótulo e valor:

struct User { let name: String; let age: Int }
let m = Mirror(reflecting: User(name: "Ann", age: 30))
for child in m.children {
    print("\(child.label ?? "?") = \(child.value)")
}
// name = Ann
// age = 30

Criando um dicionário de campos

A reflexão pode transformar uma estrutura em um dicionário:

struct Config { let host: String; let port: Int }
let m = Mirror(reflecting: Config(host: "x", port: 80))
var dict: [String: Any] = [:]
for c in m.children { if let l = c.label { dict[l] = c.value } }
print(dict["port"]!)  // 80

displayStyle

Mirror informa um displayStyle — .struct, .class, .enum, .tuple, .collection etc. — para que você possa escolher um caminho com base no tipo de valor.

Inspecionando o estilo de exibição

Identifique que tipo de valor você está refletindo:

struct S { let a = 1 }
let m = Mirror(reflecting: S())
if m.displayStyle == .struct {
    print("it is a struct with \(m.children.count) field(s)")
}
// it is a struct with 1 field(s)

Refletindo uma tupla

As tuplas expõem filhos posicionais:

let m = Mirror(reflecting: (10, "hi", true))
for c in m.children { print(c.value) }
// 10
// hi
// true

Refletindo enumerações

Nos casos de enumeração com valores associados, o filho contém a carga útil:

enum Result2 { case ok(Int); case fail(String) }
let m = Mirror(reflecting: Result2.ok(42))
print(m.children.first?.value ?? "none")  // 42

Um impressor genérico de campos

A reflexão permite criar utilitários independentes de tipo:

func dump2(_ value: Any) {
    for c in Mirror(reflecting: value).children {
        print("\(c.label ?? "_"): \(c.value)")
    }
}
struct Car { let make: String; let year: Int }
dump2(Car(make: "Mini", year: 2020))
// make: Mini
// year: 2020

Custos e limitações da reflexão

Mirror é mais lento que o acesso direto e somente leitura — não é possível definir propriedades por meio dele. Use-o para depuração, registro e auxiliares de serialização, não em caminhos críticos.

struct P { let v: Int }
let m = Mirror(reflecting: P(v: 5))
print(m.children.first!.value)  // 5  (read only)

Convertendo valores refletidos

Os valores dos filhos são tipados como Any; converta-os de volta quando precisar do tipo concreto:

struct Box { let count: Int; let label: String }
let m = Mirror(reflecting: Box(count: 3, label: "hi"))
for c in m.children {
    if let n = c.value as? Int { print("int: \(n)") }
    if let s = c.value as? String { print("str: \(s)") }
}
// int: 3
// str: hi

Verificação rápida

O que a iteração sobre Mirror(reflecting: value).children fornece?

Recapitulação

Você aprendeu sobre Mirror:

Mirror(reflecting:) inspeciona um valor em tempo de execução
children fornece pares de rótulo e valor
displayStyle informa se o valor é uma estrutura, uma classe, uma enumeração, uma tupla ou uma coleção
É somente leitura e mais lento — ótimo para depuração e serialização, mas não para caminhos críticos

A seguir: criando tipos fáceis de depurar.

Perguntas Frequentes

A aula “Reflexão com Mirror” é grátis?

Sim — o texto completo de “Reflexão com Mirror” é 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 “Reflexão com Mirror”?

Inspecione as propriedades de qualquer valor em tempo de execução. 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 3 de 4.

Quanto tempo leva a aula “Reflexão com Mirror”?

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