Swift Academy · Lección

Fundamentos de KeyPath

Use propiedades como valores de primera clase.

Fundamentos de KeyPath es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué es una ruta de clave?

Una ruta de clave es un valor que describe el camino hasta una propiedad sin acceder realmente a ella. Puede pensar en ella como una referencia almacenada y reutilizable a qué propiedad desea, separada de qué instancia utiliza para leerla.

Se escribe una ruta de clave con una barra inversa, el nombre del tipo, un punto y el nombre de la propiedad. Swift proporciona a esta expresión un valor KeyPath que puede pasar como cualquier otro valor.

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

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

Lectura de un valor

Para leer una propiedad mediante una ruta de clave, use el subíndice [keyPath:] sobre una instancia. Pase la ruta de clave entre corchetes y Swift devolverá el valor situado en esa ruta.

Esto equivale en tiempo de ejecución a escribir directamente el nombre de la propiedad, pero ahora la propiedad se elige mediante datos en lugar de estar codificada explícitamente.

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

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

Sintaxis detallada de las rutas de clave

La forma general consta de la barra inversa, el tipo raíz, un punto y el nombre de la propiedad. La barra inversa indica a Swift que desea una ruta de clave en lugar del valor de la propiedad.

El tipo raíz es el tipo desde el que comienza la ruta. El tipo de resultado es el tipo de la propiedad final. Por tanto, una ruta desde Person hasta su propiedad age tiene Person como raíz e Int como tipo de valor.

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])

Encadenamiento a través de propiedades anidadas

Las rutas de clave pueden acceder a valores anidados. Si una propiedad es a su vez una estructura, puede continuar la ruta con otro punto para llegar a una propiedad más profunda.

Toda la cadena sigue siendo un único valor de ruta de clave, y sus tipos raíz y de resultado reflejan el inicio y el final de la cadena.

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])

Almacenamiento de rutas de clave en variables

Como una ruta de clave es simplemente un valor, puede almacenarla en una variable, devolverla desde una función o conservar una colección de rutas de clave. Esto le permite decidir en tiempo de ejecución qué propiedad leer.

Aquí elegimos una de dos rutas de clave almacenadas según un indicador.

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 y AnyKeyPath

Swift dispone de una pequeña familia de tipos de rutas de clave. KeyPath<Root, Value> conoce ambos extremos. PartialKeyPath<Root> conoce la raíz, pero omite el tipo de valor. AnyKeyPath omite ambos.

Cuanta más información de tipos conserve, más comprobaciones podrá realizar el compilador por usted. Recurra a las formas parcial o any solo cuando realmente necesite combinar rutas con distintos tipos de valor.

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 un tipo conocido

Cuando el tipo raíz ya se conoce por el contexto, puede omitir el nombre del tipo y escribir solo la barra inversa, un punto y la propiedad. El compilador infiere la raíz.

Esta forma abreviada mantiene breves los lugares de llamada, especialmente dentro de operaciones de colecciones donde el tipo de elemento es 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))

Rutas de clave como argumentos de función

Un patrón habitual es una función genérica que acepta una ruta de clave y la aplica a varias instancias. Esto separa qué se lee de la lógica que realiza la lectura.

Aquí, un auxiliar genérico extrae cualquier propiedad de cualquier tipo a partir de una lista de personas.

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))

Rutas de clave y propiedades calculadas

Las rutas de clave de solo lectura también funcionan con propiedades calculadas. La ruta captura el cálculo, por lo que leer a través de ella ejecuta el getter.

Esto significa que una ruta de clave no se limita a las propiedades almacenadas: cualquier propiedad que se pueda leer es 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])

Ruta de clave de identidad

Existe una ruta de clave especial que hace referencia al valor completo, escrita como una barra inversa aislada seguida de un punto y self. Leer mediante ella devuelve la instancia sin cambios.

Resulta útil cuando una API espera una ruta de clave, pero desea el elemento tal cual, como al ordenar números por sí mismos.

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

Comparación de rutas de clave

Las rutas de clave son Hashable y Equatable. Dos rutas de clave que apuntan a la misma propiedad del mismo tipo son iguales, por lo que puede almacenarlas en conjuntos o utilizarlas como claves de diccionario.

Esto resulta útil para crear tablas que asignen una etiqueta o un formateador a una propiedad.

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")

Comprobación rápida: lectura mediante una ruta de clave

Compruebe cuánto ha entendido sobre cómo leer una propiedad mediante una ruta de clave.

Resumen: fundamentos de las rutas de clave

Ha aprendido los fundamentos de las rutas de clave:

Una ruta de clave se escribe con una barra inversa, el tipo raíz, un punto y el nombre de una propiedad, y describe una propiedad sin leerla.
Lea un valor mediante el subíndice [keyPath:] de una instancia.
Las rutas pueden encadenarse a propiedades anidadas y dirigirse a propiedades calculadas.
KeyPath, PartialKeyPath y AnyKeyPath intercambian seguridad de tipos por flexibilidad.
Las rutas de clave son valores: puede almacenarlas, pasarlas, compararlas y utilizarlas como claves de diccionario.

A continuación, utilizará rutas de clave para hacer mucho más concisas las operaciones con colecciones.

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])")

Preguntas frecuentes

¿La lección «Fundamentos de KeyPath» es gratis?

Sí — el texto completo de «Fundamentos de KeyPath» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Fundamentos de KeyPath»?

Use propiedades como valores de primera clase. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Fundamentos de KeyPath»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Swift Academy