Swift之深入解析如何进行多重条件排序

一、前言

  • 在一个条件或者单个属性上进行排序非常简单, Swift 本身就有相关的功能。
  • 如下所示,对 int 数组进行排序的例子:
let numbers = [3, 5, 6, 1, 8, 2]
let sortedNumbers = numbers.sorted { (lhs, rhs) in
    return lhs < rhs
}

// [1, 2, 3, 5, 6, 8]
  • 但有时需要根据多个条件或属性来进行排序,那么该怎么处理呢?为了演示这一点,我们可以创建一个结构体来说明。如下所示,现有一个简单的 BlogPost 结构体,它包含帖子标题和两个统计数据,即浏览次数 pageView 和会话持续时间 sessionDuration:
struct BlogPost {
    let title: String
    let pageView: Int
    let sessionDuration: Double
}
  • Sample 数据:
extension BlogPost {
    static var examples: [BlogPost] = [
        BlogPost(title: "Alice",  pageView: 1, sessionDuration: 3),
        BlogPost(title: "Peter",  pageView: 1, sessionDuration: 2),
        BlogPost(title: "Kofi",   pageView: 1, sessionDuration: 1),
        BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2),
        BlogPost(title: "Abena",  pageView: 4, sessionDuration: 10)
    ]
}
  • 如果想查看哪些文章表现良好,可以按照浏览次数对它们直接进行排序,但是很多帖子都不那么流行,页面浏览量也一样。在这种情况下,需要根据另一个条件或属性来进行进一步的排序。下面来分析一下多属性排序,它们有各种各样的方法来解决这个问题,这里只展示没有任何复杂概念的最基本的方法,一旦了解了基本原理,就可以随心所欲地进阶。

二、多条件排序

  • 多条件排序是指比较第一个条件的排序,只有当第一个条件相等时,才转到下一个条件,直到找到一个不相等的条件。
  • 伪代码如下所示:
let sortedObjects = objects.sorted { (lhs, rhs) in
    for (lhsCriteria, rhsCriteria) in [(lhsCrtria1, rhsCriteria1), (lhsCrtria2, rhsCriteria2), (lhsCrtria3, rhsCriteria3), ... , (lhsCrtriaN, rhsCriteriaN)] { // ① 
        if lhsCriteria == rhsCriteria {  // ②
            continue
        }
        return lhsCriteria < rhsCriteria // ③
    }
}
    • ① 从最重要的一个(也就是第一个)开始,循环遍历条件列表;
    • ② 如果这个顺序条件相等,不能根据它来决定顺序,就跳到下一个条件;
    • ③ 如果可以根据条件决定两个对象之间的顺序,就停止并返回结果。

三、按照两个字段对 object 数组进行排序

  • 使用前面提到的场景,我们希望根据表现对 BlogPost 进行排序,表现取决于页面浏览次数 pageView,如果浏览次数相同,再看 sessionDuration。
  • 如下所示,是上一个例子中用到的 BlogPost 结构体和对应的 sample 数据:
struct BlogPost {
    let title: String
    let pageView: Int
    let sessionDuration: Double
}

extension BlogPost {
    static var examples: [BlogPost] = [
        BlogPost(title: "Alice",  pageView: 1, sessionDuration: 3),
        BlogPost(title: "Peter",  pageView: 1, sessionDuration: 2),
        BlogPost(title: "Kofi",   pageView: 1, sessionDuration: 1),
        BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2),
        BlogPost(title: "Abena",  pageView: 4, sessionDuration: 10)
    ]
}
  • 衡量表现的方法可以翻译成下面这样的代码:
let popularPosts = BlogPost.examples.sorted { (lhs, rhs) in if lhs.pageView == rhs.pageView { // ① return lhs.sessionDuration > rhs.sessionDuration }

  return lhs.pageView > rhs.pageView // ②
}
    • ① 如果博客文章有相同的访问次数,使用访问时间;
    • ② 如果访问次数不相等,可以直接根据访问次数来排序(使用降序)。
  • 排序的结果:
[BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2.0), 
BlogPost(title: "Abena",   pageView: 4, sessionDuration: 10.0), 
BlogPost(title: "Alice",   pageView: 1, sessionDuration: 3.0), 
BlogPost(title: "Peter",   pageView: 1, sessionDuration: 2.0), 
BlogPost(title: "Kofi",    pageView: 1, sessionDuration: 1.0)]

四、按照多个字段对 object 数组进行排序

  • 不难发现,根据两个条件来排序非常简单,让我们引入更多的条件,如果博客文章的表现相同,按照 title 排序,添加更多的 sample 数据:
extension BlogPost {
    static var examples2: [BlogPost] = [
        BlogPost(title: "Zoo",    pageView: 5, sessionDuration: 2),
        BlogPost(title: "Alice",  pageView: 1, sessionDuration: 3),
        BlogPost(title: "Peter",  pageView: 1, sessionDuration: 2),
        BlogPost(title: "Kofi",   pageView: 1, sessionDuration: 1),
        BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2),
        BlogPost(title: "Abena",  pageView: 4, sessionDuration: 10),
        BlogPost(title: "Angero", pageView: 1, sessionDuration: 2)
    ]
}
  • 两个条件和三个条件没什么区别,可以沿用相同的逻辑:
let popularPosts = BlogPost.examples2.sorted { (lhs, rhs) in
    if lhs.pageView == rhs.pageView {
    	// 添加另一个if来检查博客文章是否具有相同的会话持续时间,如果它们具有相同的页面浏览次数和会话持续时间,则按标题对它们进行排序
        if lhs.sessionDuration == rhs.sessionDuration { 
            return lhs.title < rhs.title
        }       
        return lhs.sessionDuration > rhs.sessionDuration
    }
    
    return lhs.pageView > rhs.pageView
}
  • 排序结果:
[BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2.0),
 BlogPost(title: "Zoo",    pageView: 5, sessionDuration: 2.0),
 BlogPost(title: "Abena",  pageView: 4, sessionDuration: 10.0),
 BlogPost(title: "Alice",  pageView: 1, sessionDuration: 3.0),
 BlogPost(title: "Angero", pageView: 1, sessionDuration: 2.0),
 BlogPost(title: "Peter",  pageView: 1, sessionDuration: 2.0),
 BlogPost(title: "Kofi",   pageView: 1, sessionDuration: 1.0)]
  • 可以对两个和三个条件使用相同的逻辑,这里唯一的问题是,条件越多,需要的嵌套就越多。如下所示,这是一个多条件的例子,可能会导致 pyramid of doom:
let popularPosts = BlogPost.examples2.sorted { (lhs, rhs) in
    if lhs.pageView == rhs.pageView {
        if lhs.sessionDuration == rhs.sessionDuration { 
            if lhs.nextCriteria == rhs.nextCriteria { 
                if lhs.nextCriteria == rhs.nextCriteria { 
                    ....
                }

                ...
            }

            ...
        }   
        return lhs.sessionDuration > rhs.sessionDuration
    }
    return lhs.pageView > rhs.pageView
}

五、按照 N 个字段对 object 数组进行排序

  • 为了避免 pyramid of doom,再看看之前的伪代码:
let sortedObjects = objects.sorted { (lhs, rhs) in
    for (lhsCriteria, rhsCriteria) in [(lhsCrtria1, rhsCriteria1), (lhsCrtria2, rhsCriteria2), (lhsCrtria3, rhsCriteria3), ... , (lhsCrtriaN, rhsCriteriaN)] {
        if lhsCriteria == rhsCriteria {
            continue
        }

        return lhsCriteria < rhsCriteria
    }
}
  • 上面的代码不是解决类似问题的唯一方式,不过关键思路是相似的,关键思路就是把多个条件打包到一个集合当中去遍历:
extension BlogPost {
    static var examples2: [BlogPost] = [
        BlogPost(title: "Zoo",    pageView: 5, sessionDuration: 2),
        BlogPost(title: "Alice",  pageView: 1, sessionDuration: 3),
        BlogPost(title: "Peter",  pageView: 1, sessionDuration: 2),
        BlogPost(title: "Kofi",   pageView: 1, sessionDuration: 1),
        BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2),
        BlogPost(title: "Abena",  pageView: 4, sessionDuration: 10),
        BlogPost(title: "Angero", pageView: 1, sessionDuration: 2)
    ]
}

typealias AreInIncreasingOrder = (BlogPost, BlogPost) -> Bool // ①
    
let popularPosts = BlogPost.examples2.sorted { (lhs, rhs) in    
    let predicates: [AreInIncreasingOrder] = [ // ②
        { $0.pageView > $1.pageView },
        { $0.sessionDuration > $1.sessionDuration},
        { $0.title < $1.title }
    ]
    
    for predicate in predicates { // ③
        if !predicate(lhs, rhs) && !predicate(rhs, lhs) { // ④
            continue // ⑤
        }
        
        return predicate(lhs, rhs) // ⑥
    }
    
    return false
}
  • 分析说明:
    • ① 声明一个别名 AreInIncreasingOrder 用来匹配排序闭包,这可以提高对谓词集合声明的可读性;
    • ② 声明一个谓词集合;
    • ③ 遍历这个谓词集合;
    • ④ 这里是关键逻辑,想要检查条件是否能决定博文顺序,但是 AreInIncreasingOrder 返回了一个布尔值,我们应该如何判断它们是否相等? 先来看看定义,AreInIncreasingOrder 是一个谓词,它会在第一个参数能决定顺序时返回 true 否则返回 false,两个变量只有在各自都不是升序时才相等;这意味着无论参数顺序如何,谓词都必须是 false,换言之 lhs.pageView < rhs.pageView 和 rhs.pageView < lhs.pageView 必须等于 false 才能决定顺序相等,这就是 !predicate(lhs, rhs) && !predicate(rhs, lhs) 这句代码的意思;
    • ⑤ 如果顺序相等,那么 continue 到下一个谓词;
    • ⑥ 如果顺序不相等,那么可以用这个谓词来排序。
  • 排序结果:
[BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2.0), 
 BlogPost(title: "Zoo",    pageView: 5, sessionDuration: 2.0), 
 BlogPost(title: "Abena",  pageView: 4, sessionDuration: 10.0), 
 BlogPost(title: "Alice",  pageView: 1, sessionDuration: 3.0), 
 BlogPost(title: "Angero", pageView: 1, sessionDuration: 2.0), 
 BlogPost(title: "Peter",  pageView: 1, sessionDuration: 2.0),
 BlogPost(title: "Kofi",   pageView: 1, sessionDuration: 1.0)]
上一篇:外观模式


下一篇:装饰模式