Question

我正在使用equatable协议，以便基于一个名为mediaUID的属性比较两个自定义对象。
是否可以在比较不同属性之间进行切换？
在func fetchNotificationsRemoved中，有时我需要按mediaUID或likeUID进行比较。

 var notificationsArray = [NotificationInformation]()

class NotificationInformation {

    let type: String
    let mediaUID: String?
    let commentUID: String?
    let likeUID:String?    
}


extension NotificationInformation {
    func fetchNotificationsRemoved(query: DatabaseQuery) {

    NotificationInformation.observeNewNotificationsChildRemoved(query: query) { [weak self] (newNotification: NotificationInformation?) in

            guard let strongSelf = self else {return}
            guard let notification = newNotification else {return}

        if notification.type == "like" {

            // How to compare based on likeUID using equatable?
            //compare based on likeUID
            //get the index of the item of type 'like' in notificationsArray and do something with it
            guard let index = strongSelf.notificationsArray.index(of: notification) else {return}

        }else if notification.type == "media" {
            // How to compare based on mediaUID using equatable?
            //compare based on mediaUID
            //get the index of the item of type 'media' in notificationsArray
            guard let index = strongSelf.notificationsArray.index(of: notification) else {return}
        } else if if notification.type == "commentUID" {
           ....
   }


            guard let index = strongSelf.notificationsArray.index(of: notification) else {return}

            strongSelf.notificationsArray.remove(at: index)

            let visibleIndexes = strongSelf.tableView.indexPathsForVisibleRows
            let indexPathOfRemovedNotification = IndexPath(row: index, section: 0)

            if let indexes = visibleIndexes,
                indexes.contains(indexPathOfRemovedNotification) {
                strongSelf.tableView.deleteRows(at: [indexPathOfRemovedNotification], with: .fade)
            }
        }
    }

}//end extension

//enables us to compare two objects of type NotificationInformation
extension NotificationInformation: Equatable { }

func ==(lhs: NotificationInformation ,rhs: NotificationInformation) -> Bool {
    guard let mediaUIDLeft = lhs.mediaUID else {return false}
    guard let mediaUIDRight = rhs.mediaUID else {return false}
    return mediaUIDLeft == mediaUIDRight
}

Answer 1

您可以使用static var来建立要用于比较的字段：

class NotificationInformation: Equatable {
    enum CompareField {
        case type, mediaUID, commentUID, likeUID
    }

    static var compareField: CompareField = .mediaUID

    let type: String
    let mediaUID: String?
    let commentUID: String?
    let likeUID:String?

    init(type: String, mediaUID: String? = nil, commentUID: String? = nil, likeUID: String? = nil) {
        self.type = type
        self.mediaUID = mediaUID
        self.commentUID = commentUID
        self.likeUID = likeUID
    }

    static func ==(lhs: NotificationInformation, rhs: NotificationInformation) -> Bool {
        switch NotificationInformation.compareField {
        case .type:
            return lhs.type == rhs.type
        case .mediaUID:
            return lhs.mediaUID == rhs.mediaUID
        case .commentUID:
            return lhs.commentUID == rhs.commentUID
        case .likeUID:
            return lhs.likeUID == rhs.likeUID
        }
    }
}

示例：

let a = NotificationInformation(type: "foo", mediaUID: "123")
let b = NotificationInformation(type: "bar", mediaUID: "123")

NotificationInformation.compareField = .type
if a == b {
    print("same type")
}

NotificationInformation.compareField = .mediaUID
if a == b {
    print("same mediaUID")
}

输出：

same mediaUID

使用OptionSet

比较多个字段

如果将enum替换为OptionSet，则可以选择多个字段进行比较：

struct CompareFields: OptionSet {
    let rawValue: Int

    static let type       = CompareFields(rawValue: 1 << 0)
    static let mediaUID   = CompareFields(rawValue: 1 << 1)
    static let commentUID = CompareFields(rawValue: 1 << 2)
    static let likeUID    = CompareFields(rawValue: 1 << 3)
}

static var compareFields: CompareFields = .mediaUID

static func ==(lhs: NotificationInformation, rhs: NotificationInformation) -> Bool {
    var equal = true

    if NotificationInformation.compareFields.contains(.type) {
        equal = equal && (lhs.type == rhs.type)
    }
    if NotificationInformation.compareFields.contains(.mediaUID) {
        equal = equal && (lhs.mediaUID == rhs.mediaUID)
    }
    if NotificationInformation.compareFields.contains(.commentUID) {
        equal = equal && (lhs.commentUID == rhs.commentUID)
    }
    if NotificationInformation.compareFields.contains(.likeUID) {
        equal = equal && (lhs.likeUID == rhs.likeUID)
    }

    return equal
}

示例

let a = NotificationInformation(type: "foo", mediaUID: "123", commentUID: "111")
let b = NotificationInformation(type: "bar", mediaUID: "123", commentUID: "111")

NotificationInformation.compareFields = .mediaUID
if a == b {
    print("same mediaUID")
}

NotificationInformation.compareFields = [.mediaUID, .commentUID]
if a == b {
    print("same mediaUID and commentUID")
}

输出

same mediaUID
same mediaUID and commentUID

多线程问题

如果您的代码正在修改另一个线程中的compareFields值，则会出现问题。对于所有线程，equals的含义都会改变。一种可能的解决方案是仅更改主线程中的NotificationInformation并使用其相等性。

...
} else if notification.type == "media" {
    DispatchQueue.main.async {
        NotificationInformation.compareFields = .mediaUID

        guard let index = strongSelf.notificationsArray.index(of: notification) else {return}

        // use index
        ...
    }
}
...

Answer 2

将您的func更改为此：

          func ==(lhs: NotificationInformation ,rhs: NotificationInformation) -> Bool {
            guard let mediaUIDLeft = lhs.mediaUID else {return false}
            guard let mediaUIDRight = rhs.mediaUID else {return false}

            return (mediaUIDLeft == mediaUIDRight || lhs.likeUID == rhs.likeUID)
         }

这意味着如果两个NotificationInformation具有相同的mediaUID 或或同一个likeUID
是相等的

如果需要条件检查，可以引入一个布尔变量：

    class NotificationInformation {

      let type: String
      let mediaUID: String?
      let commentUID: String?
      let likeUID:String?    

      let checkByMediaUID: Bool = true

    }

因此更改您的Equatable：

      func ==(lhs: NotificationInformation ,rhs: NotificationInformation) -> Bool {
          guard let mediaUIDLeft = lhs.mediaUID else {return false}
          guard let mediaUIDRight = rhs.mediaUID else {return false}

          return (lhs.checkByMediaUID || rhs.checkByMediaUID) ? mediaUIDLeft == mediaUIDRight : lhs.likeUID == rhs.likeUID
      }

以更具可读性的方式：

   func ==(lhs: NotificationInformation ,rhs: NotificationInformation) -> Bool {
          guard let mediaUIDLeft = lhs.mediaUID else {return false}
          guard let mediaUIDRight = rhs.mediaUID else {return false}

          if lhs.checkByMediaUID || rhs.checkByMediaUID{
              return mediaUIDLeft == mediaUIDRight
          }

          return lhs.likeUID == rhs.likeUID
      }

这意味着如果要按mediaUID进行检查，只需比较两个对象。如果要通过likeUID检查，只需更改对象之一的变量。

示例

     let a: NotificationInformation = NotificationInformation()
     let b: NotificationInformation = NotificationInformation()

     //Check by `mediaUID`
     if a == b{
        ....
     }

     //Check by `likeUID`
     a.checkByMediaUID = false

     if a == b{
        ....
     }

Answer 3

您可以检查type对象的NotificationInformation属性，并根据此属性比较对象。

extension NotificationInformation: Equatable {
    static func == (lhs: NotificationInformation, rhs: NotificationInformation) -> Bool {
        guard lhs.type == rhs.type  else {
            print("Types of lhs and rhs are not same ")
            return false
        }
        switch lhs.type {
        case "like": return lhs.likeUID == rhs.likeUID
        case "media": return lhs.mediaUID == rhs.mediaUID
        case "commentUID": return lhs.commentUID == rhs.commentUID
        default: return false
        }
    }
}

您可以将enum属性用于type

class NotificationInformation {
    enum NotificationType: String {
        case like
        case media
        case commentUID
    }
    let type: NotificationType
    let mediaUID: String?
    let commentUID: String?
    let likeUID:String?
}

extension NotificationInformation: Equatable {
    static func == (lhs: NotificationInformation, rhs: NotificationInformation) -> Bool {
        guard lhs.type == rhs.type  else {
            print("Types of lhs and rhs are not same ")
            return false
        }
        switch lhs.type {
        case .like: return lhs.likeUID == rhs.likeUID
        case .media: return lhs.mediaUID == rhs.mediaUID
        case .commentUID: return lhs.commentUID == rhs.commentUID
        }
    }
}

用法

extension NotificationInformation {
    func fetchNotificationsRemoved(query: DatabaseQuery) {
        NotificationInformation.observeNewNotificationsChildRemoved(query: query) { [weak self] newNotification in
            guard let strongSelf = self else {return}
            guard let notification = newNotification else {return}
            guard let index = strongSelf.notificationsArray.index(of: notification) else {return}
            strongSelf.notificationsArray.remove(at: index)
            let visibleIndexes = strongSelf.tableView.indexPathsForVisibleRows
            let indexPathOfRemovedNotification = IndexPath(row: index, section: 0)
            if let indexes = visibleIndexes, indexes.contains(indexPathOfRemovedNotification) {
                strongSelf.tableView.deleteRows(at: [indexPathOfRemovedNotification], with: .fade)
            }
        }
    }
}

如何使用Equatable比较基于不同属性的自定义对象？

3 个答案: