日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
Swift中如何進行多重條件排序

[[399875]]

本文轉(zhuǎn)載自微信公眾號「Swift 社區(qū)」，作者喜歡Swift的小安子。轉(zhuǎn)載本文請聯(lián)系Swift 社區(qū)公眾號。

前言

在一個條件或者單個屬性上進行排序非常簡單， Swift 本身就有相關的功能。

下面是對 int 數(shù)組進行排序的例子：

 
 
 
    
  
  
  
  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.

但有時我們需要根據(jù)多個條件或?qū)傩詠磉M行排序。為了演示這一點，我們創(chuàng)建一個結(jié)構體來作為示例。

這里我們有一個簡單的 BlogPost 結(jié)構體，它包含帖子標題和兩個統(tǒng)計數(shù)據(jù)，即瀏覽次數(shù)pageView和會話持續(xù)時間sessionDuration。

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

Sample 數(shù)據(jù)：

 
 
 
    
  
  
  
  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.

如果您想查看哪些文章表現(xiàn)良好，可以按照瀏覽次數(shù)對它們直接進行排序。但是很多帖子都不那么流行，頁面瀏覽量也一樣。在這種情況下，需要根據(jù)另一個條件或?qū)傩詠磉M行進一步的排序。

我們將在本文中討論這種多屬性排序。他們有各種各樣的方法來解決這個問題。我將展示沒有任何復雜概念的最基本的方法。一旦你了解了基本原理，你就可以隨心所欲地進階了。

什么是多條件排序

多條件排序是指我們比較第一個條件的排序，只有當?shù)谝粋€條件相等時，我們才轉(zhuǎn)到下一個條件。我們這樣做直到找到一個不相等的條件。

偽代碼如下所示：

 
 
 
    
  
  
  
  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> 我們從最重要的一個(也就是第一個)開始，循環(huán)遍歷條件列表。

<2> 如果這個順序條件相等，我們不能根據(jù)它來決定順序，就跳到下一個條件。

<3> 如果我們可以根據(jù)條件決定兩個對象之間的順序，我們就停止并返回結(jié)果。

如果你很難理解偽代碼，不用擔心。我不是一個偽代碼專業(yè)作家。下面的例子應該更清楚一點。

按照兩個字段對object數(shù)組進行排序

我們使用前面提到的場景，我們希望根據(jù)表現(xiàn)對BlogPost進行排序。

我們的表現(xiàn)取決于頁面瀏覽次數(shù)pageView，如果瀏覽次數(shù)相同，我們再看sessionDuration。

下面是上一個例子中用到的BlogPost結(jié)構體和對應的sample數(shù)據(jù)。

 
 
 
    
  
  
  
  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.

我們衡量表現(xiàn)的方法可以翻譯成下面這樣的代碼：

 
 
 
    
  
  
  
  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>如果博客文章有相同的訪問次數(shù)，我們使用訪問時間。

<2>如果訪問次數(shù)不相等，我們可以直接根據(jù)訪問次數(shù)來排序(我們使用降序)

排序的結(jié)果：

 
 
 
    
  
  
  
  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數(shù)組進行排序

不難發(fā)現(xiàn)，根據(jù)兩個條件來排序非常簡單。讓我們引入更多的條件。如果博客文章的表現(xiàn)相同，我們按照title排序。

添加更多的sample數(shù)據(jù)：

 
 
 
    
  
  
  
  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.

兩個條件和三個條件沒什么區(qū)別，我們可以沿用相同的邏輯：

 
 
 
    
  
  
  
  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來檢查博客文章是否具有相同的會話持續(xù)時間，如果它們具有相同的頁面瀏覽次數(shù)和會話持續(xù)時間，則按標題對它們進行排序。

排序結(jié)果：

 
 
 
    
  
  
  
  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數(shù)組進行排序

為了避免 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 是一個謂詞，他會在第一個參數(shù)能決定順序時返回 true 否則返回 false 。兩個變量只有在各自都不是升序時才相等。

這意味著無論我們的參數(shù)順序如何，謂詞都必須是 false。換言之 lhs.pageView < rhs.pageView 和 rhs.pageView < lhs.pageView必須等于false才能決定順序相等。這就是我們 !predicate(lhs, rhs) && !predicate(rhs, lhs) 這句代碼的意思。

<5> 如果順序相等，那么 continue 到下一個謂詞。

<6> 如果順序不相等，那么我們可以用這個謂詞來排序。

排序結(jié)果：

 
 
 
    
  
  
  
  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.

結(jié)語

最近，我遇到了這個問題，覺得很有趣。這是一項簡單的任務，不過需要我花些時間去掌握。

 

本文中的方法與 Swift 沒有強關聯(lián)。你可以把它應用到任何語言上。您可以改進代碼，使其更通用，以支持所需的任何對象或?qū)傩?，我將此作為您的練習。如果你有什么有趣的發(fā)現(xiàn)，你可以在 Twitter 上和我分享你的結(jié)果。我很想看到你的實踐。

 


網(wǎng)頁題目：Swift中如何進行多重條件排序
鏈接URL：http://www.5511xx.com/article/cdojjhp.html