如何通过反射获取OptionSet选项对应的名称字符串？

Got it, let's solve this problem! You need a generic function that takes any OptionSet instance and returns the name of its corresponding static case (like turning Ability.read into "read"), using reflection since you don't know the concrete OptionSet type upfront. Here's a solid implementation tailored to your needs:

The Generic Function Implementation #

func convertOptionToString<OS: OptionSet>(optionSet: OS) -> String? {
    // First, ensure we're dealing with a single option (per your requirement to skip multi-value cases)
    guard optionSet.rawValue.nonzeroBitCount == 1 else {
        return nil
    }
    
    // Use Swift's reflection API to inspect the OptionSet type's static properties
    let typeMirror = Mirror(reflecting: OS.self)
    
    // Iterate through all static properties of the OptionSet type
    for child in typeMirror.children {
        // Extract the property name (label) and cast its value to the OptionSet type
        guard let caseName = child.label, let caseValue = child.value as? OS else {
            continue
        }
        
        // Match the raw value of the input option to the static case's raw value
        if caseValue.rawValue == optionSet.rawValue {
            return caseName
        }
    }
    
    // Return nil if no matching static case is found
    return nil
}

How It Works #

Let's break down the key parts:

1. Single Option Check: We use nonzeroBitCount to verify the input is a single, individual option (since valid single-option OptionSet cases have raw values that are powers of 2, meaning only one bit is set). This aligns with your request to ignore multi-value combinations.
2. Reflection of Static Properties: By creating a Mirror for OS.self (the type itself, not an instance), we can access all static properties defined on the OptionSet type.
3. Match Raw Values: We loop through each static property, compare its raw value to the input's raw value, and return the property's name (label) when we find a match.

Testing with Your Ability Type #

Using your example OptionSet:

struct Ability: OptionSet {
    let rawValue: Int
    static let create = Ability(rawValue: 1 << 0)
    static let read = Ability(rawValue: 1 << 1)
    static let update = Ability(rawValue: 1 << 2)
    static let delete = Ability(rawValue: 1 << 3)
}

// Test the function
let readPerm = Ability.read
if let name = convertOptionToString(optionSet: readPerm) {
    print(name) // Output: "read"
}

let createPerm = Ability.create
print(convertOptionToString(optionSet: createPerm)) // Output: Optional("create")

Notes #

• If you pass a multi-value combination (like Ability.read + Ability.update), the function returns nil as expected.
• This relies on the static property names exactly matching the string you want to return. If you have a static property with a different name than the desired output, you'd need to add a mapping layer, but this works perfectly for your stated use case.

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