Swift Academy · Aula

Noções Básicas de KeyPath

Trate propriedades como valores de primeira classe.

Noções Básicas de KeyPath é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 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 é um caminho de chave?

Um caminho de chave é um valor que descreve o caminho até uma propriedade sem acessá-la de fato. Pense nele como uma referência armazenada e reutilizável à propriedade que você deseja, separada da instância da qual você a lê.

Você escreve um caminho de chave com uma barra invertida, o nome do tipo, um ponto e o nome da propriedade. O Swift fornece a essa expressão um valor KeyPath que pode ser passado como qualquer outro valor.

struct Person {
    let name: String
    let age: Int
}

let nameKeyPath = \Person.name
print(type(of: nameKeyPath))

Lendo um valor

Para ler uma propriedade por meio de um caminho de chave, utilize o subscrito [keyPath:] em uma instância. Passe o caminho de chave entre colchetes, e o Swift retornará o valor nesse caminho.

Esse é o equivalente em tempo de execução a escrever diretamente o nome da propriedade, mas agora a propriedade é escolhida por dados, em vez de ser definida diretamente no código.

struct Person {
    let name: String
    let age: Int
}

let alice = Person(name: "Alice", age: 30)
let path = \Person.name
print(alice[keyPath: path])

Sintaxe dos caminhos de chave em detalhes

A forma geral é o escape da barra invertida, seguido pelo tipo raiz, um ponto e o nome da propriedade. A barra invertida sinaliza ao Swift que você deseja um caminho de chave, e não o valor da propriedade.

O tipo raiz é o tipo do qual o caminho parte. O tipo do resultado é o tipo da propriedade final. Assim, um caminho de Person até sua propriedade age tem raiz Person e valor Int.

struct Person {
    let name: String
    let age: Int
}

let ageKeyPath: KeyPath<Person, Int> = \Person.age
let bob = Person(name: "Bob", age: 42)
print(bob[keyPath: ageKeyPath])

Encadeando propriedades aninhadas

Os caminhos de chave podem avançar por valores aninhados. Se uma propriedade for uma estrutura, você poderá continuar o caminho com outro ponto para alcançar uma propriedade mais profunda.

Toda a cadeia continua sendo um único valor de caminho de chave, e seus tipos raiz e de resultado refletem o início e o fim da cadeia.

struct Address {
    let city: String
}
struct Person {
    let name: String
    let address: Address
}

let cityPath = \Person.address.city
let carol = Person(name: "Carol", address: Address(city: "Oslo"))
print(carol[keyPath: cityPath])

Armazenando caminhos de chave em variáveis

Como um caminho de chave é apenas um valor, você pode armazená-lo em uma variável, retorná-lo de uma função ou manter uma coleção de caminhos de chave. Isso permite decidir em tempo de execução qual propriedade ler.

Aqui, escolhemos um de dois caminhos de chave armazenados com base em um flag.

struct Person {
    let name: String
    let age: Int
}

let showAge = true
let chosen: PartialKeyPath<Person> = showAge ? \Person.age : \Person.name
let dave = Person(name: "Dave", age: 27)
print(dave[keyPath: chosen])

PartialKeyPath e AnyKeyPath

O Swift tem uma pequena família de tipos de caminho de chave. KeyPath<Root, Value> conhece as duas extremidades. PartialKeyPath<Root> conhece a raiz, mas apaga o tipo do valor. AnyKeyPath apaga ambos.

Quanto mais informações de tipo você mantiver, mais o compilador poderá verificar por você. Recorra às formas parcial ou genérica somente quando realmente precisar combinar caminhos com tipos de valor diferentes.

struct Person {
    let name: String
    let age: Int
}

let paths: [PartialKeyPath<Person>] = [\.name, \.age]
let eve = Person(name: "Eve", age: 19)
for p in paths {
    print(eve[keyPath: p])
}

Forma abreviada dentro de um tipo conhecido

Quando o tipo raiz já é conhecido pelo contexto, você pode omitir o nome do tipo e escrever apenas a barra invertida, um ponto e a propriedade. O compilador infere a raiz.

Essa forma abreviada mantém curtos os locais de chamada, especialmente dentro de operações de coleção nas quais o tipo do elemento é evidente.

struct Person {
    let name: String
    let age: Int
}

func value(of person: Person, at path: KeyPath<Person, Int>) -> Int {
    person[keyPath: path]
}

let frank = Person(name: "Frank", age: 55)
print(value(of: frank, at: \.age))

Caminhos de chave como argumentos de função

Um padrão comum é uma função genérica que aceita um caminho de chave e o aplica a várias instâncias. Isso separa o que você lê da lógica que realiza a leitura.

Aqui, um auxiliar genérico extrai qualquer propriedade de qualquer tipo de uma lista de people.

struct Person {
    let name: String
    let age: Int
}

func extract<T>(_ people: [Person], _ path: KeyPath<Person, T>) -> [T] {
    people.map { $0[keyPath: path] }
}

let people = [Person(name: "Ana", age: 21), Person(name: "Ben", age: 34)]
print(extract(people, \.name))
print(extract(people, \.age))

Caminhos de chave e propriedades calculadas

Os caminhos de chave somente leitura também funcionam com propriedades calculadas. O caminho captura o cálculo, portanto a leitura por meio dele executa o getter.

Isso significa que um caminho de chave não se limita a propriedades armazenadas; qualquer propriedade legível é válida.

struct Rectangle {
    let width: Double
    let height: Double
    var area: Double { width * height }
}

let areaPath = \Rectangle.area
let r = Rectangle(width: 3, height: 4)
print(r[keyPath: areaPath])

Caminho de chave de identidade

Existe um caminho de chave especial que se refere ao próprio valor inteiro, escrito como uma barra invertida isolada seguida por um ponto e self. A leitura por meio dele retorna a instância sem alterações.

Ele é útil quando uma API espera um caminho de chave, mas você deseja o próprio elemento, como ao ordenar números por seus próprios valores.

let numbers = [3, 1, 2]
let identity = \Int.self
for n in numbers {
    print(n[keyPath: identity])
}

Comparando caminhos de chave

Os caminhos de chave são Hashable e Equatable. Dois caminhos de chave que apontam para a mesma propriedade do mesmo tipo são iguais, portanto você pode armazená-los em conjuntos ou usá-los como chaves de dicionário.

Isso é útil para criar tabelas que associam uma propriedade a um rótulo ou formatador.

struct Person {
    let name: String
    let age: Int
}

let labels: [PartialKeyPath<Person>: String] = [
    \Person.name: "Full Name",
    \Person.age: "Years Old"
]
print(labels[\Person.age] ?? "unknown")

Verificação rápida: lendo por meio de um caminho de chave

Teste sua compreensão sobre como ler uma propriedade por meio de um caminho de chave.

Recapitulação: fundamentos dos caminhos de chave

Você aprendeu os fundamentos dos caminhos de chave:

Um caminho de chave é escrito com uma barra invertida, o tipo raiz, um ponto e o nome de uma propriedade, e descreve uma propriedade sem lê-la.
Leia um valor usando o subscrito [keyPath:] em uma instância.
Os caminhos podem ser encadeados em propriedades aninhadas e apontar para propriedades calculadas.
KeyPath, PartialKeyPath e AnyKeyPath trocam segurança de tipos por flexibilidade.
Os caminhos de chave são valores: armazene-os, passe-os, compare-os e use-os como chaves de dicionário.

Em seguida, você usará caminhos de chave para tornar as operações de coleção muito mais concisas.

struct Person {
    let name: String
    let age: Int
}

let path = \Person.age
let gina = Person(name: "Gina", age: 48)
print("Read via key path: \(gina[keyPath: path])")

Perguntas Frequentes

A aula “Noções Básicas de KeyPath” é grátis?

Sim — o texto completo de “Noções Básicas de KeyPath” é 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 “Noções Básicas de KeyPath”?

Trate propriedades como valores de primeira classe. 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 4.

Quanto tempo leva a aula “Noções Básicas de KeyPath”?

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