Swift自定义数据的相等逻辑、数据打印（Equatable,CustomStringConvertible）

项目开发过程中，经常需要判断某些数据是否相同（比如：判断Array数组中是否包含某个元素element，以便快速编辑、删除）。直接使用系统自带方法（element==element、Array.contains(element)）,很多情况下都不符合业务逻辑。这时就需要对元素element做些处理了。（文章最后有代码示例：😄）

方法1：遵循Equatable协议，并实现下边的方法:

 static func == (lhs: Self, rhs: Self) -> Bool

方法2：继承NSObject。同样也需要重写（static func ==）这个方法，但是数组的contains方法无法正确运转，这是因为contains方法依赖于了NSObjectProtocol协议的isEqual方法，所以还需要重写isEqual方法才行

public static func == (lhs: NSObject, rhs: NSObject) -> Bool

func isEqual(_ object: Any?) -> Bool

关于判断相等的问题基本就如此了，再说说打印问题

 因为项目中的开发调试过程中，常需要用print方法在控制台上打印数据。但是若不做处理，打印出来的往往是地址，这并不是我们需要的，所以还需要处理下

如果类是继承自NSObject，直接重写description和debugDescription就行，debugDescription我很少用到，所以我一般就只重写了description方法

    var description: String { get }

    
    optional var debugDescription: String { get }

 如果类没有继承NSObject，name就需要我们自己去遵循CustomStringConvertible协议，并实现description方法

var description: String { get }

最后是示例：

•  继承自NSObject:

/// 继承自NSObject
class ZJObjectElement:NSObject {
    var id:Int
    var name:String
    init(_ id:Int, _ name:String = "") {
        self.id = id
        self.name = name
    }
    // 使用id作为判断是否相等的条件
    static func == (lhs: ZJObjectElement, rhs: ZJObjectElement) -> Bool {
        return (
            lhs.id == rhs.id
        )
    }
    // 由于是继承了NSObject，所以还需要重写这个方法才能正擦使用数组的contains方法
    override func isEqual(_ object: Any?) -> Bool {
        if let object = object as? ZJObjectElement {
            return (
                object.id == self.id
            )
        }else{
            return false
        }
    }
    
    /// 重写打印方法
    override var description: String{
        return "{id:\(id),name:\(name)}"
    }
    
    /// 只能说很少重写这个
    override var debugDescription: String{
//        return "{id:\(id),name:\(name)}"
        return self.description // 没特殊需求的话，可以这么写,省事..😄
    }
}

•  使用Equatable和CustomStringConvertible（CustomDebugStringConvertible看自己的情况）：

/// 可以是struct也可以是class
struct ZJObjectElement:Equatable,CustomStringConvertible,CustomDebugStringConvertible {
    var id:Int
    var name:String
    init(_ id:Int, _ name:String = "") {
        self.id = id
        self.name = name
    }
    // 使用id作为判断是否相等的条件
    static func == (lhs: ZJObjectElement, rhs: ZJObjectElement) -> Bool {
        return (
            lhs.id == rhs.id
        )
    }
    
    /// 重写打印方法
    var description: String{
        return "{id:\(id),name:\(name)}"
    }

    /// CustomDebugStringConvertible协议的方法
    var debugDescription: String{
//        return "{id:\(id),name:\(name)}"
        return self.description // 同上，没特殊需求的话，可以这么写,省事..😄
    }
}

打印测试：

    /// 打印测试
    func printTest() {
        let m1 = ZJObjectElement(1,"m1")
        let m2 = ZJObjectElement(2,"m2")
        let m3 = ZJObjectElement(1,"m3")
        let array = [ZJObjectElement(1,"array_m1"),ZJObjectElement(4,"array_m4")]
        
        print(m1)                   //  {id:1,name:m1}
        print(m2)                   //  {id:2,name:m2}
        print(m3)                   //  {id:1,name:m3}
        print(array)                //  [{id:1,name:array_m1}, {id:4,name:array_m4}]
        print(m1 == m2)             //  false
        print(m1 == m3)             //  true
        print(array.contains(m1))   //  true
        print(array.contains(m2))   //  false
    }