Question

我正在尝试比较2个数据数组，每个数据数组都是从结构体构建的。这背后的潜在想法是将来自本地数据的数组与来自网络数据的数组进行比较，如果它们相同则使用本地数据以试图节省时间，尤其是当某些数据是图像时。

我为了测试而模拟的基本代码如下，但是我似乎无法比较数组，因为它们来自结构？有办法解决这个问题吗？

func compareQuery() {

    struct packStructNW {
        var packName : String
        var packDescription : String
        var packTitle : String
        var packImage : PFFile
        var packID: String
    }

    var packArrayNW = [packStructNW]()

    struct packStructLDS {
        var packName : String
        var packDescription : String
        var packTitle : String
        var packImage : PFFile
        var packID: String
    }

    var packArrayLDS = [packStructLDS]()

    if self.connected {
        let packQueryNW = PFQuery(className: "Pack")
            packQueryNW.order(byAscending: "packName")
            packQueryNW.findObjectsInBackground(block: { (objectsArray, error) in
                if error != nil {
                    print(error!)
                } else {
                    if let packs = objectsArray {
                        for object in packs {
                            let arrayName = object.object(forKey: "packName") as! String
                            let arrayDescription = object.object(forKey: "packDescription") as! String
                            let arrayTitle = object.object(forKey: "packTitle") as! String
                            let arrayImage = object.object(forKey: "packImage") as! PFFile
                            let arrayID = object.objectId as String!
                            packArrayNW.append(packStructNW(packName: arrayName, packDescription: arrayDescription, packTitle: arrayTitle, packImage: arrayImage, packID: arrayID!))

                        }
                    }
                }
            })

        let packQueryLDS = PFQuery(className: "Pack")
        packQueryLDS.order(byAscending: "packName")
        packQueryLDS.fromLocalDatastore()
        packQueryLDS.findObjectsInBackground(block: { (objectsArray, error) in
            if error != nil {
                print(error!)
            } else {
                if let packs = objectsArray {
                    for object in packs {
                        let arrayName = object.object(forKey: "packName") as! String
                        let arrayDescription = object.object(forKey: "packDescription") as! String
                        let arrayTitle = object.object(forKey: "packTitle") as! String
                        let arrayImage = object.object(forKey: "packImage") as! PFFile
                        let arrayID = object.objectId as String!
                        packArrayLDS.append(packStructLDS(packName: arrayName, packDescription: arrayDescription, packTitle: arrayTitle, packImage: arrayImage, packID: arrayID!))

                    }
                }
            }
        })

        print(packArrayNW)

        print(packArrayLDS)

        if packArrayLDS == packArrayNW {
            print("they are the same")
        } else {
            print("they are different")
        }


    }


}

-----------------编辑--------------------

感谢解决方案WERUreo。

最后我必须将equatable部分移动到struct的扩展以使其工作。我确信你所展示的方式确实有效，我无法在没有错误的情况下实现。

它比较了数组，我现在唯一的问题是，由于我在后台获取数据，因此我运行比较代码的时间并没有完全填充数组。任何想法如何在运行代码进行比较之前等待数组的填充？

在主要课堂内

struct myStruct {
    var packName : String
    var packDescription : String
    var packTitle : String
    var packImage : PFFile
    var packID: String
}

在主要课程之外

extension PackViewController.myStruct: Equatable {}

func ==(lhs: PackViewController.myStruct, rhs: PackViewController.myStruct) -> Bool {
    let areEqual = lhs.packName == rhs.packName &&
                    lhs.packDescription == rhs.packDescription &&
                    lhs.packTitle == rhs.packTitle &&
                    lhs.packImage === rhs.packImage &&
                    lhs.packID == rhs.packID
    return areEqual
}

Answer 1

首先，您不需要定义两个单独的结构。一个结构适用于网络和本地。您还希望使结构符合Equatable协议。 Equatable有一个必需的函数，即==运算符。所以对于你的结构，你可能会做类似的事情：

struct packStruct: Equatable {
    var packName : String
    var packDescription : String
    var packTitle : String
    var packImage : PFFile
    var packID: String

    static func ==(lhs: packStruct, rhs: packStruct) -> Bool {
        return lhs.packName == rhs.packName &&
               lhs.packDescription == rhs.packDescription &&
               lhs.packTitle == rhs.packTitle &&
               lhs.packImage == rhs.packImage && // you need to make sure PFFile is also Equatable
               lhs.packID == rhs.packID
    }
}

然后你应该能够比较两个packStruct数组。

Answer 2

您必须为不同类型的数组定义相等性。下面的代码对我有用。

func ==(lhs: [packStructNW], rhs: [packStructLDS]) -> Bool {
   ...
}

func ==(lhs: [packStructNW], rhs: [packStructNW]) -> Bool {
    ...
}

func ==(lhs: [packStructLDS], rhs: [packStructNW]) -> Bool {
    ...
}

func ==(lhs: [packStructLDS], rhs: [packStructLDS]) -> Bool {
    ...
}

struct packStructNW {}

struct packStructLDS {}

var packArrayNW = [packStructNW]()
var packArrayLDS = [packStructLDS]()

if packArrayNW == packArrayLDS {

} else {

}

比较2个struct Arrays

2 个答案: