Question

使用Swift 2.1我尝试创建一个函数，按键dateKey的日期值对字典数组进行排序。

我想将其添加为Array类型的扩展名，因此我可以使用someArray.sortDictionariesByDate(dateKey: String, dateFormatter: NSDateFormatter)

来调用它

extension Array where Element: CollectionType {
  mutating func sortDictionariesByDate(dateKey: String, dateFormatter: NSDateFormatter) {
    sortInPlace {
      dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZ"
      if let dateStringA: String = ($0 as? [String: AnyObject])?[dateKey] as? String, let dateStringB = ($1 as? [String: AnyObject])?[dateKey] as? String {
        if let dateA: NSDate = dateFormatter.dateFromString(dateStringA), dateB: NSDate = dateFormatter.dateFromString(dateStringB) {
          return dateA.compare(dateB) == .OrderedAscending
        }
      }
      return false
    }
  }
}

只要字典被输入为[String: AnyObject]，这样就行得很好，但是如果我在类型为[String: String]的字典上使用它，它就不起作用，因为它无法使用将String投射到AnyObject。我认为这是因为String是Struct而不是Class。我也尝试将元素强制转换为[String: Any]，但无论使用[String: AnyObject]或[String: String]类型的字典，它都无法工作。

我是否可以使用任何强制转换来支持密钥类型为String的字典和任何值类型（String，AnyObject等），或者可能是where子句或协议一致性可以添加到扩展名以避免完全投射？

编辑：根据请求，这是两个示例数组

var sampleArray1: [[String: AnyObject]] = [["date": "2015-10-24T13:00:00.000Z", "foo": "bar"], ["date": "2015-10-24T14:00:00.000Z", "foo": "bar"]]
sampleArray1.sortDictionariesByDate("date", dateFormatter: NSDateFormatter())
var sampleArray2: [[String: String]] = [["date": "2015-10-24T13:00:00.000Z", "foo": "bar"], ["date": "2015-10-24T14:00:00.000Z", "foo": "bar"]]
sampleArray2.sortDictionariesByDate("date", dateFormatter: NSDateFormatter())

Answer 1

第一个问题：您正在比较字符串，而不是日期。幸运的是，您的字符串格式使其可以直接与字符串及其表示的日期值进行比较。因此，您根本不需要将其转换为NSDate。

第二个问题是，即使Dictionary<Key,Value1> Dictionary<Key,Value2> Value1 Value2 let a : [String: String] = ["name": "David", "location": "Chicago"] let b = a as [String: AnyObject]，String到a批发也不起作用。它可能在像这样的微不足道的例子中起作用......

extension Array where Element: CollectionType {
    mutating func sortDictionariesByDate(dateKey: String) {
        self.sortInPlace {
            if let a = $0 as? NSDictionary, b = $1 as? NSDictionary {
                return (a[dateKey] as? String) < (b[dateKey] as? String)
            } else {
                return false
            }
        }
    }
}

// Example:
var sampleArray1: [[String: AnyObject]] = [
    ["date": "2015-10-24T13:00:00.000Z", "foo": "bar"],
    ["date": "2015-10-24T14:00:00.000Z", "foo": "bar"],
    ["date": "2015-10-24T10:00:00.000Z", "foo": "bar"]
]
var sampleArray2: [[String: String]] = [
    ["date": "2015-10-24T13:00:00.000Z", "foo": "bar"], 
    ["date": "2015-10-24T14:00:00.000Z", "foo": "bar"],
    ["date": "2015-10-24T10:00:00.000Z", "foo": "bar"]
]

sampleArray1.sortDictionariesByDate("date")
sampleArray2.sortDictionariesByDate("date")

...因为编译器可以在NSDateFormatter中看到值类型（{{1}}）并通过编译时间对其进行优化。对于像你这样的动态情况，没有提前获得的信息。

当你需要活力时，你总是可以回到老朋友，Objective-C：

{{1}}

请注意，由于您现在正在比较字符串而不是日期，因此不需要{{1}}。

Answer 2

你要求做的是愚蠢的。你不打算编写一个在[[String:AnyObject]]和[[String:String]]上都可以运行的单一函数。 Swift有严格的打字。这就是它的样子。演员，快乐！

投射像字典这样的复杂类型的数组的技巧是使用map单独转换每个元素（这实际上是在幕后的数组转换）：

let sampleArray1: [[String: AnyObject]] = [["date": "2015-10-24T13:00:00.000Z", "foo": "bar"], ["date": "2015-10-24T14:00:00.000Z", "foo": "bar"]]
let sampleArray2: [[String: String]] = [["date": "2015-10-24T13:00:00.000Z", "foo": "bar"], ["date": "2015-10-24T14:00:00.000Z", "foo": "bar"]]

func sortByDate(arr:[[String:AnyObject]]) -> [[String:AnyObject]] {
    let result = arr.sort {
        d1, d2 in
        let dat1 = NSDateFormatter().dateFromString(d1["date"] as! String)!
        let dat2 = NSDateFormatter().dateFromString(d2["date"] as! String)!
        return dat1.timeIntervalSinceReferenceDate < dat2.timeIntervalSinceReferenceDate
    }
    return result
}

let arr1 = sortByDate(sampleArray1)
let arr2 = sortByDate(sampleArray2.map{$0 as [String:AnyObject]})
// and if you have to, `map` arr2 back down to [String:String]

我承认我没有完全填写规范，但添加更多参数很容易，因此您提供了密钥名称和格式化程序。请注意，该示例实际上会崩溃您的数据，因为我们没有匹配的日期格式。您需要提供有效的格式。

我也认为（作为同一点的一部分），你把日期字符串放入字典而不是实际日期是愚蠢的。但是，为了争论，我已经同意了这个前提。

Answer 3

这是一个不同的解决方案，在处理函数内的转换时将函数保持为Array的扩展，从而避免在处理不同类型的字典时必须来回使用.map()。缺点是你必须提前知道函数支持的类型，而@matt的解决方案允许你在调用方法时处理转换，代价是不作为扩展，不进行排序和映射回来类推。

extension Array where Element: CollectionType {
  mutating func sortDictionariesByDate(dateKey: String, dateFormatter: NSDateFormatter) {
    sortInPlace {
      dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZ"
      var dateString1: String?
      var dateString2: String?

      if let a = $0 as? [String: AnyObject], let b = $1 as? [String: AnyObject] {
        if let dateStringA: String = a[dateKey] as? String, dateStringB: String = b[dateKey] as? String {
          dateString1 = dateStringA
          dateString2 = dateStringB
        }
      } else if let a = $0 as? [String: String], let b = $1 as? [String: String] {
        dateString1 = a[dateKey]
        dateString2 = b[dateKey]
      }

      if let dateString1: String = dateString1, let dateString2: String = dateString2 {
        if let date1: NSDate = dateFormatter.dateFromString(dateString1), date2: NSDate = dateFormatter.dateFromString(dateString2) {
          return date1.timeIntervalSinceReferenceDate < date2.timeIntervalSinceReferenceDate
        }
      }
      return false
    }
  }
}

// Example:
var sampleArray1: [[String: AnyObject]] = [
    ["date": "2015-10-24T13:00:00.000Z", "foo": "bar"],
    ["date": "2015-10-24T14:00:00.000Z", "foo": "bar"],
    ["date": "2015-10-24T10:00:00.000Z", "foo": "bar"]
]
var sampleArray2: [[String: String]] = [
    ["date": "2015-10-24T13:00:00.000Z", "foo": "bar"], 
    ["date": "2015-10-24T14:00:00.000Z", "foo": "bar"],
    ["date": "2015-10-24T10:00:00.000Z", "foo": "bar"]
]

sampleArray1.sortDictionariesByDate("date")
sampleArray2.sortDictionariesByDate("date")

Swift数组字典扩展sortInPlace

3 个答案: