能否从CodingKey获取KeyPath？或有无自动实现的替代方案？

Great question! Let's break this down clearly:

Short Answer #

No, you can't directly retrieve a KeyPath from a CodingKey out of the box. CodingKey types are just wrappers for string/integer identifiers that map to JSON keys—they don't have a built-in connection to the compile-time KeyPaths of your model properties. The Swift compiler doesn't generate this mapping automatically.

But don't worry, there are automatic, no-manual-computed-properties solutions for read-only access, depending on your Swift version and needs.

Automatic Solution 1: Reflection (Works with all Swift versions) #

You can use Swift's Mirror API to dynamically map a CodingKey's raw value to the corresponding property KeyPath of your model. This requires zero manual property definitions—just a generic extension on Decodable:

import Foundation

extension Decodable {
    func keyPath(for codingKey: some CodingKey) -> PartialKeyPath<Self>? {
        let mirror = Mirror(reflecting: self)
        
        // Iterate through all top-level properties
        for child in mirror.children {
            guard let propertyName = child.label else { continue }
            
            // Match the property name to the CodingKey's raw value
            // Note: This assumes your CodingKey raw values match property names (default Codable behavior)
            if propertyName == codingKey.rawValue {
                return NSExpression(forKeyPath: propertyName).keyPath as PartialKeyPath<Self>
            }
        }
        
        // For nested properties, you'd add recursive logic here (optional, based on your needs)
        return nil
    }
}

How to use it #

If your model uses the default Codable synthesis (where property names match JSON keys), this works out of the box:

struct User: Decodable {
    let name: String
    let age: Int
}

let sampleUser = User(name: "Caleb", age: 28)

// Use the auto-synthesized CodingKey to get the KeyPath
if let nameKeyPath = sampleUser.keyPath(for: User.CodingKey.name) {
    let userName = sampleUser[keyPath: nameKeyPath] as? String
    print(userName) // Output: "Caleb"
}

Caveats #

• Reflection has minor performance overhead compared to direct KeyPath access, but it's negligible for most read-only use cases.
• If you use custom CodingKey definitions where raw values don't match property names (e.g., case userName = "user_name"), you'll need to adjust the matching logic (e.g., add a mapping layer in your CodingKey type).

Automatic Solution 2: Swift Macros (Swift 5.9+) #

For optimal performance and full automation, use Swift Macros to generate a keyPath property for your CodingKey type at compile time. This eliminates manual work entirely and gives you the same performance as hand-written KeyPath references.

Example Macro Setup #

First, define a macro that generates the KeyPath mapping:

import SwiftSyntax
import SwiftSyntaxMacros
import SwiftSyntaxMacrosTestSupport

public struct CodingKeyWithKeyPathMacro: MemberMacro {
    public static func expansion(
        of node: AttributeSyntax,
        providingMembersOf declaration: some DeclGroupSyntax,
        in context: some MacroExpansionContext
    ) throws -> [DeclSyntax] {
        guard let structDecl = declaration as? StructDeclSyntax else {
            throw MacroError.onlyApplicableToStructs
        }
        
        // Get all properties of the struct
        let properties = structDecl.memberBlock.members.compactMap { $0.decl as? VariableDeclSyntax }
        
        // Generate the CodingKey extension with keyPath cases
        let codingKeyExtension = """
        extension \(structDecl.name).CodingKey {
            var keyPath: PartialKeyPath<\(structDecl.name)> {
                switch self {
                \(properties.map { prop in
                    let propName = prop.bindings.first?.pattern.as(IdentifierPatternSyntax.self)?.identifier.text ?? ""
                    return "case .\(propName): return \\.\(structDecl.name).\(propName)"
                }.joined(separator: "\n"))
                }
            }
        }
        """
        
        return [DeclSyntax(stringLiteral: codingKeyExtension)]
    }
}

// Register the macro
@main
struct CodingKeyMacroPlugin: CompilerPlugin {
    let providingMacros: [Macro.Type] = [
        CodingKeyWithKeyPathMacro.self
    ]
}

Usage #

Add the macro to your model, and it will auto-generate the keyPath property for your CodingKey:

@CodingKeyWithKeyPath
struct User: Decodable {
    let name: String
    let age: Int
    let email: String
}

// Now you can directly access the KeyPath from the CodingKey
let sampleUser = User(name: "Caleb", age: 28, email: "caleb@example.com")
let emailValue = sampleUser[keyPath: User.CodingKey.email.keyPath] as? String
print(emailValue) // Output: "caleb@example.com"

Benefits #

• Compile-time safety: No runtime reflection overhead.
• 100% automatic: No manual KeyPath definitions needed—just add the macro attribute.
• Works with custom CodingKey: You can adjust the macro to handle custom raw values if needed.

Final Notes #

• If you need a quick, no-setup solution, the reflection approach works across all Swift versions.
• For production code where performance matters, Swift Macros are the best automatic option (requires Swift 5.9+).

内容的提问来源于stack exchange，提问作者Caleb Kleveter