Zusammenführen mehrerer Eigenschaften der Objekte in einer

Question

Sagen wir, ich diese Klasse haben:

class Person { 
    var firstName: String! 
    var lastName: String! 
    var phoneNumber: String? 
    var email: String? 
    var address: String? 
} 

Jetzt instanziiert ich dies:

let person1 = Person() 
person1.firstName = "Nicolas" 
person1.lastName = "Cage" 
person1.phoneNumber = "999-999-999" 
person1.address = "No 123, NYC" 

let person2 = Person() 
person2.firstName = "Nicolas" 
person2.lastName = "Cage" 
person2.phoneNumber = "123-1234-1234" 
person2.address = "No 123, NYC" 
person2.email = "nicolas@nicolas.com" 

let person3 = Person() 
person3.firstName = "John" 
person3.lastName = "Travolta" 

Und ich habe dieses Array:

let actors: [Person] = [person1, person2, person3] 

Wie Kann ich duplizierte Personen kombinieren/zusammenführen, wenn keine Konflikte bestehen, und die Liste widersprüchlicher Eigenschaften enthalten?

Erwartete Eigenschaftswerte von Nicoals Cage nach merge:

Nicolas 
Cage 
phoneNumber -> Conflict 
No 123, NYC 
nicolas@nicolas.com 

Answer 1

private func merge(actors:[Person]) -> [Person] { 

    var uniqueActors = [Person]() 
    var duplicatedActors = [Person]() 

    //split actors into arrays 
    for actor in actors { 
     if uniqueActors.contains(where: { $0.firstName == actor.firstName && 
              $0.lastName == actor.lastName}) { 
      duplicatedActors.append(actor) 
     } else { 
      uniqueActors.append(actor) 
     } 
    } 

    //merge duplicated into unique 
    for duplicatedActor in duplicatedActors { 
     let uniqueActor = uniqueActors.filter({ $0.firstName == duplicatedActor.firstName && 
               $0.lastName == duplicatedActor.lastName }).first 
     if let uniqueActor = uniqueActor { 
      uniqueActor.phoneNumber = self.mergeProperty(valueOne: uniqueActor.phoneNumber, valueTwo: duplicatedActor.phoneNumber) 
      uniqueActor.address = self.mergeProperty(valueOne: uniqueActor.address, valueTwo: duplicatedActor.address) 
      uniqueActor.email = self.mergeProperty(valueOne: uniqueActor.email, valueTwo: duplicatedActor.email) 
     } 
    } 

    return uniqueActors 

} 

//merge properties of 2 objects 
private func mergeProperty(valueOne: String?, valueTwo: String?) -> String? { 
    var isFirstPropertyExist = false 
    var isSecondPropertyExist = false 

    if let valueOne = valueOne, valueOne != "" { 
     isFirstPropertyExist = true 
    } 

    if let valueTwo = valueTwo, valueTwo != "" { 
     isSecondPropertyExist = true 
    } 

    var mergedValue : String? 

    switch (isFirstPropertyExist, isSecondPropertyExist) { 
    case (true, true): 
     if valueOne != valueTwo { 
      mergedValue = "Conflict" 
      //here you can print or throw an Error 
     } else { 
      mergedValue = valueOne 
      //random (equal values) 
     } 

    case (true, false): 
     mergedValue = valueOne 
    case (false, true): 
     mergedValue = valueTwo 
    case (false, false): 
     mergedValue = "" 
     //or you can return nil 
    } 

    return mergedValue 
} 

ich denke, es kann Ihnen helfen. Sie können func mergeProperty in Verlängerung der Klasse Person und func merge in Erweiterung der Array-Klasse übergeben, wo Objekt Person