Swift中如何进行多重条件排序

[[399875]]

本文转载自微信公众号「Swift 社区」，作者喜欢Swift的小安子。转载本文请联系Swift 社区公众号。

前言

在一个条件或者单个属性上进行排序非常简单， Swift 本身就有相关的功能。

下面是对 int 数组进行排序的例子：

 
 
 
    
  
  
  
  1. let numbers = [3, 5, 6, 1, 8, 2] 
    2.   
  
  
  2.          
    3.   
  
  
  3. let sortedNumbers = numbers.sorted { (lhs, rhs) in 
    4.   
  
  
  4.     return lhs < rhs 
    5.   
  
  
  5. } 
    6.   
  
  
  6.  
    7.   
  
  
  7. // [1, 2, 3, 5, 6, 8] 
    8.

但有时我们需要根据多个条件或属性来进行排序。为了演示这一点，我们创建一个结构体来作为示例。

这里我们有一个简单的 BlogPost 结构体，它包含帖子标题和两个统计数据，即浏览次数pageView和会话持续时间sessionDuration。

 
 
 
    
  
  
  
  1. struct BlogPost { 
    2.   
  
  
  2.     let title: String 
    3.   
  
  
  3.     let pageView: Int 
    4.   
  
  
  4.     let sessionDuration: Double 
    5.   
  
  
  5. } 
    6.

Sample 数据：

 
 
 
    
  
  
  
  1. extension BlogPost { 
    2.   
  
  
  2.     static var examples: [BlogPost] = [ 
    3.   
  
  
  3.         BlogPost(title: "Alice", pageView: 1, sessionDuration: 3), 
    4.   
  
  
  4.         BlogPost(title: "Peter", pageView: 1, sessionDuration: 2), 
    5.   
  
  
  5.         BlogPost(title: "Kofi", pageView: 1, sessionDuration: 1), 
    6.   
  
  
  6.         BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2), 
    7.   
  
  
  7.         BlogPost(title: "Abena", pageView: 4, sessionDuration: 10) 
    8.   
  
  
  8.     ] 
    9.   
  
  
  9. } 
    10.

如果您想查看哪些文章表现良好，可以按照浏览次数对它们直接进行排序。但是很多帖子都不那么流行，页面浏览量也一样。在这种情况下，需要根据另一个条件或属性来进行进一步的排序。

我们将在本文中讨论这种多属性排序。他们有各种各样的方法来解决这个问题。我将展示没有任何复杂概念的最基本的方法。一旦你了解了基本原理，你就可以随心所欲地进阶了。

什么是多条件排序

多条件排序是指我们比较第一个条件的排序，只有当第一个条件相等时，我们才转到下一个条件。我们这样做直到找到一个不相等的条件。

伪代码如下所示：

 
 
 
    
  
  
  
  1. let sortedObjects = objects.sorted { (lhs, rhs) in 
    2.   
  
  
  2.     for (lhsCriteria, rhsCriteria) in [(lhsCrtria1, rhsCriteria1), (lhsCrtria2, rhsCriteria2), (lhsCrtria3, rhsCriteria3), ... , (lhsCrtriaN, rhsCriteriaN)] { // <1> 
    3.   
  
  
  3.         if lhsCriteria == rhsCriteria { // <2> 
    4.   
  
  
  4.             continue 
    5.   
  
  
  5.         } 
    6.   
  
  
  6.         return lhsCriteria < rhsCriteria // <3> 
    7.   
  
  
  7.     } 
    8.   
  
  
  8. } 
    9.

<1> 我们从最重要的一个(也就是第一个)开始，循环遍历条件列表。

<2> 如果这个顺序条件相等，我们不能根据它来决定顺序，就跳到下一个条件。

<3> 如果我们可以根据条件决定两个对象之间的顺序，我们就停止并返回结果。

如果你很难理解伪代码，不用担心。我不是一个伪代码专业作家。下面的例子应该更清楚一点。

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

我们使用前面提到的场景，我们希望根据表现对BlogPost进行排序。

我们的表现取决于页面浏览次数pageView，如果浏览次数相同，我们再看sessionDuration。

下面是上一个例子中用到的BlogPost结构体和对应的sample数据。

 
 
 
    
  
  
  
  1. struct BlogPost { 
    2.   
  
  
  2.     let title: String 
    3.   
  
  
  3.     let pageView: Int 
    4.   
  
  
  4.     let sessionDuration: Double 
    5.   
  
  
  5. } 
    6.   
  
  
  6.  
    7.   
  
  
  7. extension BlogPost { 
    8.   
  
  
  8.     static var examples: [BlogPost] = [ 
    9.   
  
  
  9.         BlogPost(title: "Alice", pageView: 1, sessionDuration: 3), 
    10.   
  
  
  10.         BlogPost(title: "Peter", pageView: 1, sessionDuration: 2), 
    11.   
  
  
  11.         BlogPost(title: "Kofi", pageView: 1, sessionDuration: 1), 
    12.   
  
  
  12.         BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2), 
    13.   
  
  
  13.         BlogPost(title: "Abena", pageView: 4, sessionDuration: 10) 
    14.   
  
  
  14.     ] 
    15.   
  
  
  15. } 
    16.

我们衡量表现的方法可以翻译成下面这样的代码：

 
 
 
    
  
  
  
  1. let popularPosts = BlogPost.examples.sorted { (lhs, rhs) in if lhs.pageView == rhs.pageView { // <1> return lhs.sessionDuration > rhs.sessionDuration } 
    2.   
  
  
  2.  
    3.   
  
  
  3.   return lhs.pageView > rhs.pageView // <2> 
    4.   
  
  
  4. } 
    5.

<1>如果博客文章有相同的访问次数，我们使用访问时间。

<2>如果访问次数不相等，我们可以直接根据访问次数来排序(我们使用降序)

排序的结果：

 
 
 
    
  
  
  
  1. [BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2.0),  
    2.   
  
  
  2. BlogPost(title: "Abena", pageView: 4, sessionDuration: 10.0),  
    3.   
  
  
  3. BlogPost(title: "Alice", pageView: 1, sessionDuration: 3.0),  
    4.   
  
  
  4. BlogPost(title: "Peter", pageView: 1, sessionDuration: 2.0),  
    5.   
  
  
  5. BlogPost(title: "Kofi", pageView: 1, sessionDuration: 1.0)] 
    6.

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

不难发现，根据两个条件来排序非常简单。让我们引入更多的条件。如果博客文章的表现相同，我们按照title排序。

添加更多的sample数据：

 
 
 
    
  
  
  
  1. extension BlogPost { 
    2.   
  
  
  2.     static var examples2: [BlogPost] = [ 
    3.   
  
  
  3.         BlogPost(title: "Zoo", pageView: 5, sessionDuration: 2), 
    4.   
  
  
  4.         BlogPost(title: "Alice", pageView: 1, sessionDuration: 3), 
    5.   
  
  
  5.         BlogPost(title: "Peter", pageView: 1, sessionDuration: 2), 
    6.   
  
  
  6.         BlogPost(title: "Kofi", pageView: 1, sessionDuration: 1), 
    7.   
  
  
  7.         BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2), 
    8.   
  
  
  8.         BlogPost(title: "Abena", pageView: 4, sessionDuration: 10), 
    9.   
  
  
  9.         BlogPost(title: "Angero", pageView: 1, sessionDuration: 2) 
    10.   
  
  
  10.     ] 
    11.   
  
  
  11. } 
    12.

两个条件和三个条件没什么区别，我们可以沿用相同的逻辑：

 
 
 
    
  
  
  
  1. let popularPosts = BlogPost.examples2.sorted { (lhs, rhs) in 
    2.   
  
  
  2.     if lhs.pageView == rhs.pageView { 
    3.   
  
  
  3.         if lhs.sessionDuration == rhs.sessionDuration { // <1> 
    4.   
  
  
  4.             return lhs.title < rhs.title 
    5.   
  
  
  5.         } 
    6.   
  
  
  6.          
    7.   
  
  
  7.         return lhs.sessionDuration > rhs.sessionDuration 
    8.   
  
  
  8.     } 
    9.   
  
  
  9.      
    10.   
  
  
  10.     return lhs.pageView > rhs.pageView 
    11.   
  
  
  11. } 
    12.

<1> 我们添加了另一个if来检查博客文章是否具有相同的会话持续时间，如果它们具有相同的页面浏览次数和会话持续时间，则按标题对它们进行排序。

排序结果：

 
 
 
    
  
  
  
  1. [BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2.0), 
    2.   
  
  
  2. BlogPost(title: "Zoo", pageView: 5, sessionDuration: 2.0), 
    3.   
  
  
  3. BlogPost(title: "Abena", pageView: 4, sessionDuration: 10.0), 
    4.   
  
  
  4. BlogPost(title: "Alice", pageView: 1, sessionDuration: 3.0), 
    5.   
  
  
  5. BlogPost(title: "Angero", pageView: 1, sessionDuration: 2.0), 
    6.   
  
  
  6. BlogPost(title: "Peter", pageView: 1, sessionDuration: 2.0), 
    7.   
  
  
  7. BlogPost(title: "Kofi", pageView: 1, sessionDuration: 1.0)] 
    8.

问题

我们可以对两个和三个条件使用相同的逻辑。这里唯一的问题是，条件越多，需要的嵌套就越多。

这是一个多条件的例子，可能会导致pyramid of doom。

 
 
 
    
  
  
  
  1. let popularPosts = BlogPost.examples2.sorted { (lhs, rhs) in 
    2.   
  
  
  2.     if lhs.pageView == rhs.pageView { 
    3.   
  
  
  3.         if lhs.sessionDuration == rhs.sessionDuration {  
    4.   
  
  
  4.             if lhs.nextCriteria == rhs.nextCriteria {  
    5.   
  
  
  5.                 if lhs.nextCriteria == rhs.nextCriteria {  
    6.   
  
  
  6.                     .... 
    7.   
  
  
  7.                 } 
    8.   
  
  
  8.  
    9.   
  
  
  9.                 ... 
    10.   
  
  
  10.             } 
    11.   
  
  
  11.  
    12.   
  
  
  12.             ... 
    13.   
  
  
  13.         } 
    14.   
  
  
  14.          
    15.   
  
  
  15.         return lhs.sessionDuration > rhs.sessionDuration 
    16.   
  
  
  16.     } 
    17.   
  
  
  17.      
    18.   
  
  
  18.     return lhs.pageView > rhs.pageView 
    19.   
  
  
  19. } 
    20.

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

为了避免 pyramid of doom, 我们再看看之前的伪代码：

 
 
 
    
  
  
  
  1. let sortedObjects = objects.sorted { (lhs, rhs) in 
    2.   
  
  
  2.     for (lhsCriteria, rhsCriteria) in [(lhsCrtria1, rhsCriteria1), (lhsCrtria2, rhsCriteria2), (lhsCrtria3, rhsCriteria3), ... , (lhsCrtriaN, rhsCriteriaN)] { 
    3.   
  
  
  3.         if lhsCriteria == rhsCriteria { 
    4.   
  
  
  4.             continue 
    5.   
  
  
  5.         } 
    6.   
  
  
  6.  
    7.   
  
  
  7.         return lhsCriteria < rhsCriteria 
    8.   
  
  
  8.     } 
    9.   
  
  
  9. } 
    10.

上面的代码不是解决类似问题的唯一方式，不过关键思路是相似的。关键思路就是把多个条件打包到一个集合当中去遍历。

 
 
 
    
  
  
  
  1. extension BlogPost { 
    2.   
  
  
  2.     static var examples2: [BlogPost] = [ 
    3.   
  
  
  3.         BlogPost(title: "Zoo", pageView: 5, sessionDuration: 2), 
    4.   
  
  
  4.         BlogPost(title: "Alice", pageView: 1, sessionDuration: 3), 
    5.   
  
  
  5.         BlogPost(title: "Peter", pageView: 1, sessionDuration: 2), 
    6.   
  
  
  6.         BlogPost(title: "Kofi", pageView: 1, sessionDuration: 1), 
    7.   
  
  
  7.         BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2), 
    8.   
  
  
  8.         BlogPost(title: "Abena", pageView: 4, sessionDuration: 10), 
    9.   
  
  
  9.         BlogPost(title: "Angero", pageView: 1, sessionDuration: 2) 
    10.   
  
  
  10.     ] 
    11.   
  
  
  11. } 
    12.   
  
  
  12.  
    13.   
  
  
  13. typealias AreInIncreasingOrder = (BlogPost, BlogPost) -> Bool // <1> 
    14.   
  
  
  14.      
    15.   
  
  
  15. let popularPosts = BlogPost.examples2.sorted { (lhs, rhs) in     
    16.   
  
  
  16.     let predicates: [AreInIncreasingOrder] = [ // <2> 
    17.   
  
  
  17.         { $0.pageView > $1.pageView }, 
    18.   
  
  
  18.         { $0.sessionDuration > $1.sessionDuration}, 
    19.   
  
  
  19.         { $0.title < $1.title } 
    20.   
  
  
  20.     ] 
    21.   
  
  
  21.      
    22.   
  
  
  22.     for predicate in predicates { // <3> 
    23.   
  
  
  23.         if !predicate(lhs, rhs) && !predicate(rhs, lhs) { // <4> 
    24.   
  
  
  24.             continue // <5> 
    25.   
  
  
  25.         } 
    26.   
  
  
  26.          
    27.   
  
  
  27.         return predicate(lhs, rhs) // <5> 
    28.   
  
  
  28.     } 
    29.   
  
  
  29.      
    30.   
  
  
  30.     return false 
    31.   
  
  
  31. } 
    32.

<1>我声明了一个别名 AreInIncreasingOrder 用来匹配排序闭包，这提高了我们对谓词集合声明的可读性

<2> 我们声明了一个谓词集合

<3> 我们遍历这个谓词集合

<4> 这里是关键逻辑，我们想要检查条件是否能决定博文顺序。但是 AreInIncreasingOrder 返回了一个布尔值. 我们应该如何判断他们是否相等? 在回答这个问题之前，我们先检查一下 AreInIncreasingOrder 的定义。

AreInIncreasingOrder 是一个谓词，他会在第一个参数能决定顺序时返回 true 否则返回 false 。两个变量只有在各自都不是升序时才相等。

这意味着无论我们的参数顺序如何，谓词都必须是 false。换言之 lhs.pageView < rhs.pageView 和 rhs.pageView < lhs.pageView必须等于false才能决定顺序相等。这就是我们 !predicate(lhs, rhs) && !predicate(rhs, lhs) 这句代码的意思。

<5> 如果顺序相等，那么 continue 到下一个谓词。

<6> 如果顺序不相等，那么我们可以用这个谓词来排序。

排序结果：

 
 
 
    
  
  
  
  1. [BlogPost(title: "Akosua", pageView: 5, sessionDuration: 2.0),  
    2.   
  
  
  2. BlogPost(title: "Zoo", pageView: 5, sessionDuration: 2.0),  
    3.   
  
  
  3. BlogPost(title: "Abena", pageView: 4, sessionDuration: 10.0),  
    4.   
  
  
  4. BlogPost(title: "Alice", pageView: 1, sessionDuration: 3.0),  
    5.   
  
  
  5. BlogPost(title: "Angero", pageView: 1, sessionDuration: 2.0),  
    6.   
  
  
  6. BlogPost(title: "Peter", pageView: 1, sessionDuration: 2.0), 
    7.   
  
  
  7. BlogPost(title: "Kofi", pageView: 1, sessionDuration: 1.0)] 
    8.

结语

最近，我遇到了这个问题，觉得很有趣。这是一项简单的任务，不过需要我花些时间去掌握。

 

本文中的方法与 Swift 没有强关联。你可以把它应用到任何语言上。您可以改进代码，使其更通用，以支持所需的任何对象或属性，我将此作为您的练习。如果你有什么有趣的发现，你可以在 Twitter 上和我分享你的结果。我很想看到你的实践。

 

分享文章：Swift中如何进行多重条件排序
地址分享：http://www.shufengxianlan.com/qtweb/news9/454209.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

企业建站知识

同城分类信息

成都app开发公司　　 　四川黔盛装饰　　 　梅州网站建设　　 　400电话申请　　 　泸州叙永网站建设　　 　免备案虚拟主机　　 　高端网站建设　　 　网站运营　　 　Android开发　　 　成都免费自助建站　　 　重庆网站建设网络公司　　 　建站公司　　 　网站建设　　 　虚拟主机　　 　东电技服　　 　消防工程　　 　网站域名　　 　正泰动物　　 　德阳做网站　　 　温江服务器托管