通过KeyPath获取值时，无法正确判断值是否为nil的问题

Hey there! Let's break down why your nil checks are acting so unexpectedly here.

The core issue lies in how Swift's generics, optional types, and KeyPaths interact—especially when working with NSObject subclasses that might have Objective-C bridged properties. Here's what's going on:
Your generic parameter Value isn't constrained to handle optional types explicitly. When you compare value == nil, Swift's type system might misinterpret the comparison depending on how Value is inferred:

• If Value is inferred as a non-optional type, comparing it to nil should trigger a compiler warning (since non-optionals can never be nil). But with Objective-C bridged properties (like implicitly unwrapped optionals or id types), Swift might let this slide at runtime but return incorrect results.
• If Value is an optional type but the comparison still fails, it's likely due to type erasure in the generic context messing up the nil check logic.

Now let's fix this with a few reliable solutions:

Solution 1: Explicitly target Optional KeyPaths #

If you only need to work with optional properties, update your function to require optional KeyPaths directly:

func myFunc<Object: NSObject, Wrapped>(in object: Object, for keyPath: KeyPath<Object, Wrapped?>) {
    let value = object[keyPath: keyPath]
    debugPrint(value, type(of: value))
    print("nil? = ", value == nil) // Now works as expected
    print("notNil? = ", value != nil) // Now works as expected
}

This forces the KeyPath to point to an optional property, so value is properly typed as Wrapped?, making nil comparisons behave correctly.

Solution 2: Generic nil check (works for all KeyPaths) #

If you need your function to handle both optional and non-optional properties, use a helper protocol to detect optional values safely:

// Helper protocol to mark optional types
private protocol OptionalIndicator {
    var isNil: Bool { get }
}

// Conform Optional to our indicator protocol
extension Optional: OptionalIndicator {
    var isNil: Bool { self == nil }
}

func myFunc<Object: NSObject, Value>(in object: Object, for keyPath: KeyPath<Object, Value>) {
    let value = object[keyPath: keyPath]
    debugPrint(value, type(of: value))
    
    // Check if the value is an optional and nil; non-optionals return false
    let isNil = (value as? OptionalIndicator)?.isNil ?? false
    
    print("nil? = ", isNil)
    print("notNil? = ", !isNil)
}

This approach uses a protocol to safely inspect whether the value is an optional and whether it holds a nil value—even in a generic context. Non-optional values will correctly return false for isNil.

Solution 3: Mirror-based check (for tricky Objective-C bridged types) #

If you're dealing with edge cases like NSNull or implicitly unwrapped optionals from Objective-C, using Mirror can help you inspect the underlying value:

func myFunc<Object: NSObject, Value>(in object: Object, for keyPath: KeyPath<Object, Value>) {
    let value = object[keyPath: keyPath]
    debugPrint(value, type(of: value))
    
    let mirror = Mirror(reflecting: value)
    // Check if it's an optional with no wrapped value
    let isNil = mirror.displayStyle == .optional && mirror.children.isEmpty
    
    print("nil? = ", isNil)
    print("notNil? = ", !isNil)
}

This works by checking the mirror's display style and whether it has any children (a sign that a wrapped value exists).

Give these solutions a shot—they should resolve your nil comparison issues!

内容的提问来源于stack exchange，提问作者EvGeniy Ilyin