如何基于用户选择动态对Struct数组进行多字段排序？

Hey there! I get what you're trying to do—avoiding a tangled mess of if-else statements when switching sort rules for your struct array is totally the right call. The issue with your current dynamic attempt is that Swift doesn’t let you reference properties using raw string variables directly like that. Instead, KeyPaths are the type-safe, clean solution here. Let me walk you through how to implement this smoothly:

Step 1: Understand KeyPaths for Dynamic Property Access #

KeyPaths let you reference struct properties in a way that’s both flexible and type-safe. No more guesswork with string identifiers or unresolved errors—they’re built specifically for scenarios like dynamic sorting.

Step 2: Build a Reusable Sort Comparator Function #

We’ll create a function that generates a custom sort closure based on your chosen primary/secondary fields and sort order. This way, you just pass in your preferences instead of rewriting closure logic every time.

// First, let's tweak the struct (optional but recommended—implicitly unwrapped optionals carry crash risks)
struct ArrayStruct {
    var stringV: String
    var intV: Int
    var dateV: Date
    var costV: Float
    var stringD: String
}

// Type alias to simplify our comparator signature
typealias ArrayStructComparator = (ArrayStruct, ArrayStruct) -> Bool

// Function to generate a tailored sort comparator
func makeArrayStructSortComparator<Primary: Comparable, Secondary: Comparable>(
    primaryKey: KeyPath<ArrayStruct, Primary>,
    secondaryKey: KeyPath<ArrayStruct, Secondary>,
    isAscending: Bool = true
) -> ArrayStructComparator {
    return { a, b in
        // Compare primary fields first
        let primaryA = a[keyPath: primaryKey]
        let primaryB = b[keyPath: primaryKey]
        
        if primaryA != primaryB {
            // Use primary field for sorting if values differ
            let primarySort = primaryA < primaryB
            return isAscending ? primarySort : !primarySort
        } else {
            // Fall back to secondary field when primary values match
            let secondaryA = a[keyPath: secondaryKey]
            let secondaryB = b[keyPath: secondaryKey]
            let secondarySort = secondaryA < secondaryB
            return isAscending ? secondarySort : !secondarySort
        }
    }
}

Step 3: Sort Dynamically Without If-Else Chaos #

Now you can switch between sort rules in seconds—no messy conditionals required. Just define your chosen keys and order, then pass the generated comparator to sort(by:):

var newArray: [ArrayStruct] = [] // Populate this with your 100 records

// Example 1: Sort by stringV (ascending), then dateV (ascending)
let sortByStringThenDate = makeArrayStructSortComparator(
    primaryKey: \.stringV,
    secondaryKey: \.dateV,
    isAscending: true
)
newArray.sort(by: sortByStringThenDate)

// Example 2: Sort by intV (descending), then costV (descending)
let sortByIntThenCostDesc = makeArrayStructSortComparator(
    primaryKey: \.intV,
    secondaryKey: \.costV,
    isAscending: false
)
newArray.sort(by: sortByIntThenCostDesc)

// Example 3: Sort by dateV (ascending), then stringD (ascending)
let sortByDateThenStringD = makeArrayStructSortComparator(
    primaryKey: \.dateV,
    secondaryKey: \.stringD
)
newArray.sort(by: sortByDateThenStringD)

Handling Optional Values (If You Need to Keep Them) #

If you can’t ditch the implicitly unwrapped optionals (!) in your original struct, add this helper extension to safely compare optional values and avoid runtime crashes:

// Extension to safely compare optional Comparable values
extension Optional where Wrapped: Comparable {
    static func < (lhs: Wrapped?, rhs: Wrapped?) -> Bool {
        switch (lhs, rhs) {
        case (nil, nil): return false
        case (nil, _): return true // Treat nil as "smaller" so it appears first in sorted results
        case (_, nil): return false
        case let (l?, r?): return l < r
        }
    }
}

// Restore your original struct with optionals if needed
struct ArrayStruct {
    var stringV: String!
    var intV: Int!
    var dateV: Date!
    var costV: Float!
    var stringD: String!
}

This approach keeps your code DRY (Don’t Repeat Yourself) and makes adding new sort rules later trivial—just call the generator function with different key paths and order settings. No more endless if-else chains!

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