Vergleichen 2 struct Arrays

Question

Ich spielte mit der Idee, 2 Datenfelder zu vergleichen, von denen jedes aus einer Struktur aufgebaut ist. Die mögliche Idee dahinter war, ein Array von lokalen Daten mit einem Array aus Netzwerkdaten zu vergleichen. Wenn sie identisch sind, verwenden Sie die lokalen Daten, um Zeit zu sparen, insbesondere wenn einige der Daten Bilder sind.

Basic-Code ich verspottet zum Testen ist unten, aber ich kann nicht in der Lage sein, die Array zu vergleichen, weil sie von einer Struktur sind? Gibt es einen Weg dahin?

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") 
     } 


    } 


} 

----------------- EDIT --------------------

Dank für die Lösung WERUreo.

Am Ende musste ich den equatable Teil zu einer Erweiterung der Struktur verschieben, um es zu arbeiten. Ich bin mir sicher, dass die Art und Weise, wie Sie gezeigt haben, funktioniert, ich konnte es einfach nicht ohne Fehler passieren lassen.

Vergleichen Sie die Arrays, nur das Problem, das ich jetzt habe, ist, dass die Arrays nicht vollständig von der Zeit gefüllt sind, die ich den Compare-Code ausführen, wie ich die Daten im Hintergrund bekomme. Haben Sie eine Idee, wie Sie auf das Array warten müssen, bevor Sie den zu vergleichenden Code ausführen?

innen Hauptklasse

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

außerhalb Hauptklasse

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

Also zuerst, sollten Sie nicht zwei separate Strukturen definieren müssen. Eine Struktur würde sowohl für das Netzwerk als auch für das lokale Netzwerk funktionieren. Sie möchten auch, dass die Struktur dem Protokoll Equatable entspricht. Equatable hat eine erforderliche Funktion, die == Operator ist. Also für Ihre Struktur, werden Sie wahrscheinlich etwas tun würden, wie:

Dann sollten Sie in der Lage sein, zwei Arrays von packStruct zu vergleichen.

Answer 2

Sie haben für Array von verschiedenen Typen Gleichheit zu definieren. Der folgende Code funktioniert für mich.

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 { 

}