数组 – 如何在Swift中比较Equatable

我有两组这样的两个数组.我从第三方获得他们.

var array1 : [Any?]
var array2 : [Any?]

我知道这些数组中的对象类型(在编译时).例如,第一个元素是String,第二个是Int.

我目前比较每组数组(请注意数组不是同类的).

array1[0] as? String == array2[0] as? String
array1[1] as? Int == array2[1] as? Int
...

每个集合中存在不同类型的最大问题.结果,我想说10组数组,每组有5个元素.我不得不做10 * 5显式转换为特定类型和比较.

我希望能够编写一个可以比较两个数组的公共方法(无需指定所有类型)

compareFunc(array1, array2)

我开始走下去了.但是,我无法弄清楚我应该如何施放物体.我试过Equatable.但是,swift并不喜欢直接使用它.所以,这样的事情不起作用

func compare(array1: [Any?], array2: [Any?]) {
    for index in 0..<array1.count {
       if (array1[index] as? Equatable != array2[index] as? Equatable) {
         // Do something
       }
    }
}

此数组中的每个对象都是Equatable.但是,我不确定如何在这种情况下使用它.

基于(尝试)类型转换为已知元素类型构造简单的逐元素比较函数

由于您的目标是比较(可选)任何元素的数组,您可以构建一个函数,通过使用开关块尝试将数组的元素向下转换为“不同的已知类型”来执行逐元素比较.第三方阵列“.请注意,您无需指定与特定类型对应的元素位置(因为这可能在不同的数组集之间有所不同),只需指定任何给定元素可能具有的不同类型的详尽集合.

这种功能的一个例子如下：

func compareAnyArrays(arr1: [Any?], _ arr2: [Any?]) -> Bool {
    /* element-by-element downcasting (to known types) followed by comparison */
    return arr1.count == arr2.count && !zip(arr1, arr2).contains {

        /* note that a 'true' below indicates the arrays differ (i.e., 'false' w.r.t. array equality) */
        if let v1 = $1 {

            /* type check for known types */
            switch $0 {
            case .None: return true
            case let v0 as String:
                if let v1 = v1 as? String { return !(v0 == v1) }; return true
            case let v0 as Int:
                if let v1 = v1 as? Int { return !(v0 == v1) }; return true
            /* ...
               expand with the known possible types of your array elements
               ... */
            case _ : return true
                /*  */
            }
        }
        else if let _ = $0 { return true }
        return false
    }
}

或者,通过使用compare(...) helper function from @Roman Sausarnes:s answer(稍微修改一下)使开关块变得稍微膨胀

func compareAnyArrays(arr1: [Any?], _ arr2: [Any?]) -> Bool {

    /* modified helper function from @Roman Sausarnes:s answer */
    func compare<T: Equatable>(obj1: T, _ obj2: Any) -> Bool {
        return obj1 == obj2 as? T
    }

    /* element-by-element downcasting (to known types) followed by comparison */
    return arr1.count == arr2.count && !zip(arr1, arr2).contains {

        /* note also that a 'true' below indicates the arrays differ
         (=> false w.r.t. equality) */
        if let v1 = $1 {

            /* type check for known types */
            switch $0 {
            case .None: return true
            case let v0 as String: return !compare(v0, v1)
            case let v0 as Int: return !compare(v0, v1)
                /* ...
                 expand with the known possible types of your array elements
                 ... */
            case _ : return true
                /*  */
            }
        }
        else if let _ = $0 { return true }
        return false
    }
}

用法示例：

/* Example usage #1 */
let ex1_arr1 : [Any?] = ["foo", nil, 3, "bar"]
let ex1_arr2 : [Any?] = ["foo", nil, 3, "bar"]
compareAnyArrays(ex1_arr1, ex1_arr2) // true

/* Example usage #2 */
let ex2_arr1 : [Any?] = ["foo", nil, 2, "bar"]
let ex2_arr2 : [Any?] = ["foo", 3, 2, "bar"]
compareAnyArrays(ex2_arr1, ex2_arr2) // false