So what is a KeyPath in Swift? Lets try to answer this in a simply way, note this will not be in depth, but rather a very basic rundown of what a KeyPath is.

📘 Info Please Note: I Am not an expert and this is more or less a way for me to help cement the basics of this concept in my own mind. If this is of any Value to you, thats just an added bonus!

To begin Apple defines a keyPath as follows:

A key path from a specific root type to a specific resulting value type.

Here’s a bit more detailed definition:

A reference (“path”) to a property on a give Type. In Swift a ‘KeyPath’ is expressed as ‘\Type.property’, ‘Type’ is the struct or class. And ‘property’ would be what you want to reference


struct Superhero {
    var alias: String
    var superpower: String
}

// Defining key paths for 'alias' and 'superpower' properties of the Superhero struct.
// These constants allow indirect reference to the properties of any Superhero instance.
let aliasKeyPath = \Superhero.alias
let superpowerKeyPath = \Superhero.superpower

We just created a simple struct and set constants which hold the KeyPath.


// Creating an instance of Superhero.
// 'superhero' is now an object with 'alias' and 'superpower' properties.
var superhero = Superhero(alias: "Spider-Bro", superpower: "Web-slinging")

// Accessing property values using the key paths defined earlier.
// This demonstrates how key paths can be used to read values from specific properties.
let superheroAlias = superhero[keyPath: aliasKeyPath] // Retrieves 'alias' value: "Spider-Bro"
let superheroPower = superhero[keyPath: superpowerKeyPath] // Retrieves 'superpower' value: "Web-slinging"

// Printing the accessed values.
// It shows how to use the key paths to get property values in a readable and reusable manner.
print(superheroAlias, superheroPower)

// Accessing properties using shorthand key path syntax directly.
// This is a more concise way to use key paths, especially when they are not reused elsewhere.
print(superhero[keyPath: \.alias], superhero[keyPath: \.superpower])

We instantiate a Superhero struct here, then we access the values in two manners.

// Modifying a property value using its key path.
// This line demonstrates how key paths can also be used to set new values for specific properties.
superhero[keyPath: \.alias] = "Spider-Pig" // Changes 'alias' property to 'Spider-Pig'

// Printing the updated alias to demonstrate the change.
print(superhero[keyPath: \.alias])

Finally, we see how to modify the property values

These are the very basics of KeyPaths in Swift. I believe this should be enough to at least get you familiar with the concept to the point where SwiftUI will make a tad bit more sense when first getting started.