将Swift 3功能转换为Swift 4

我正在努力将此功能转换为Swift 4

func buildIndex(records: [Record]) -> [[Record]] {
    var g = [NSDate: [Record]]()
    for e in records {
        if (g[e.time] == nil) {
            g[e.time] = []
        }
        g[e.time]!.append(e) // grouping by `time`
    }
    return sorted(g.keys) { (a: NSDate, b: NSDate) in
        a.compare(b) == .OrderedAscending // sorting the outer array by time
    }
    // sorting the inner arrays by `name`
    .map { sorted(g[$0]!) { $0.name < $1.name } } 
}

func buildIndex（记录：[Record]）->[[Record]]{
var g=[NSDate:[记录]]（）
记录中的e{
如果（g[e.time]==nil）{
g[e.时间]=[]
}
g[e.time]！.append（e）//按`时间'分组`
}
返回已排序（g.keys）{（a:NSDate，b:NSDate）的
a、 比较（b）==.OrderedAsceding//按时间对外部数组排序
}
//按`name'对内部数组进行排序`
.map{sorted（g[$0]！）{$0.name<$1.name}
}

我希望有人能帮助我。

试试看

func buildIndex(records: [Record]) -> [[Record]] {
    var g = [NSDate: [Record]]()
    for e in records {
        if (g[e.time] == nil) {
            g[e.time] = []
        }
        g[e.time]!.append(e) // grouping by `time`
    }

    return g.keys.sorted { (a: NSDate, b: NSDate) in
        a.compare(b as Date) == .orderedAscending // sorting the outer array by time
        }
        // sorting the inner arrays by `name`
        .map { g[$0]!.sorted { $0.name < $1.name } }
}

func buildIndex（记录：[Record]）->[[Record]]{
var g=[NSDate:[记录]]（）
记录中的e{
如果（g[e.time]==nil）{
g[e.时间]=[]
}
g[e.time]！.append（e）//按`时间'分组`
}
在中返回g.keys.sorted{（a:NSDate，b:NSDate）
a、 比较（b as Date）=.orderedAscending//按时间对外部数组排序
}
//按`name'对内部数组进行排序`
.map{g[$0]！.sorted{$0.name<$1.name}
}

---

希望对你有帮助。

这里有很多东西需要清理。变量名显然是一场灾难，但强制展开也是如此。所有这些都可以用一个简单的调用

<代码>导入基础 结构记录{ 时间：日期 let name:String } func buildIndex（记录：[记录]）->任何{ 返回字典（分组：记录，按：{$0.time}） .mapValues{$0.0}{$0.name<$1.name} .sorted{（pair1，pair2）在pair1.key尝试时会发生什么？您正在努力解决哪些部分？问题已经解决，谢谢您的时间不要使用变量名，如

e

，

g

。将来你会因为它而恨你，恨任何其他将来需要阅读/维护此代码的人。Swift的排序不能保证稳定，所以这样连续进行两次排序不能保证有效。当然不能

NSDate

。甚至在Swift 3中也没有。有一个本机Swift类型

Date

import Foundation

struct Record {
    let time: Date
    let name: String
}

func buildIndex(records: [Record]) -> Any {
    return Dictionary(grouping: records, by: { $0.time })
        .mapValues { $0.sorted { $0.name < $1.name} }
        .sorted { (pair1, pair2) in pair1.key < pair2.key }
}