如何在swift中通过泛型实现对象合并？

Question

假设我有一个班级编号：

class Number {
    var val: Double?
}

并且有该类的两个实例，A 和 B。 现在想象一下我想通过这样的语句将B合并到A

merge(B, into: A)

现在我当然可以这样写函数：

func merge(from: Number, into: Number){
    into.val = from.val
}

但这根本不能重复使用。有没有办法可以编写一个通用的合并类？

更新：尽管一些答案提供了良好且可行的解决方案，但它们都不够“通用”（这里的通用是指非技术性的） .所以看答案，我得到了一些启发，这是我现在正在考虑的解决方案：将 Number 设为 NSObject 子类，并将所有可以合并的属性声明为动态。例如：

class Number: NSObject {
    //Put the required init and initWithCoder: here
    dynamic var val: Double?
}

然后声明可合并类必须遵守的协议

protocol Mergeable: class {
    var mergeablePropertyKeys:[String] {get}
}

然后声明一个执行合并的全局函数：

func merge<U: Mergeable, Mergeable where U.Type == V.Type>(from: U, into:V){
    for property in U.mergeablePropertyKeys {
        V.setValue(U.valueForKey(property), property)
    }
}

而且我知道这行不通，因为要合并的参数不一定是NSObjects。

• 如何确保merge 的参数都是NSObjects?
• 是否可以通过简单地获取对象的动态值列表来避免指定所有可合并值的名称？

Answer 1

听起来你想要的是一个使用反射来合并属性的通用函数。反射在 Swift 中是有限的，但使用 MirrorType 是可行的。我之前使用过这种方法来构建一个通用的json parser in swift - 你可以做一些类似的事情，但不是解析一个 json 字典来映射你的两个对象的属性。

在 swift 中使用反射来做这件事的一个例子：

func merge<T>(itemToMerge:T) {
    let mirrorSelf = Mirror(reflecting: self)
    let mirrorItemToMerge = Mirror(reflecting: itemToMerge)
    for mirrorSelfItem in mirrorSelf.children {
        // Loop through items in mirrorItemToMerge.
        for mirrorImageItem in mirrorItemToMerge.children {
            // If you have a parameter who's name is a match, map the value
            // OR You could add any custom mapping logic you need for your specific use case
            if mirrorSelfItem.label == mirrorImageItem.label {
                // To set values, use self.setValue(valueToSet, forKey: propertyName)
                self.setValue(mirrorImageItem.value as? AnyObject, forKey: mirrorImageItem.label!)
            }
        }
    }
}

这假定定义合并方法的对象是 NSObject 的子类（因此它可以利用 NSKeyValueCoding）。你也可以把它变成一个静态方法，可以合并任意 NSObject 类型的任意 2 个对象：

static func merge<T1: NSObject, T2: NSObject>(itemChanging:T1, itemToMerge:T2) {
    let mirrorSelf = Mirror(reflecting: itemChanging)
    let mirrorItemToMerge = Mirror(reflecting: itemToMerge)
    for mirrorSelfItem in mirrorSelf.children {
        // Loop through items in mirrorItemToMerge.
        for mirrorImageItem in mirrorItemToMerge.children {
            // If you have a parameter who's name is a match, map the value
            // OR You could add any custom mapping logic you need for your specific use case
            if mirrorSelfItem.label == mirrorImageItem.label {
                // To set values, use self.setValue(valueToSet, forKey: propertyName)
                self.setValue(mirrorImageItem.value as? AnyObject, forKey: mirrorImageItem.label!)
            }
        }
    }
}

Answer 2

我不确定您的期望，但有通用解决方案：

class Number<T> {
    var val: T?
}

protocol Merge {
    func merge(from: Self, into: Self)
}

extension Number: Merge {
    func merge(from: Number, into: Number) {
        into.val = from.val
    }
}

Answer 3

协议

让我们像这样定义一个HasValue 协议（仅适用于类）

protocol HasValue: class {
    typealias T
    var val: T? { get set }
}

合并

现在我们可以定义一个泛型函数

func merge<U: HasValue, V:HasValue where U.T == V.T>(from: U, into:V) {
    into.val = from.val
}

函数签名中的约束确实保证了

1. 两个参数都符合HasValue（因此是类）
2. val 两个参数的类型相等

场景一：params 类型相同

class Number: HasValue {
    var val: Double?
}

let one = Number()
one.val = 1

let two = Number()
two.val = 2

merge(one, into: two)
print(two.val) // Optional(1.0)

场景2：参数类型不同，但值类型相同

我没有将Merge 的2 个参数限制为具有相同的类型，我只是检查2 个参数的val 属性必须具有相同的类型。

所以我们还可以合并具有相同类型的 val 的不同类的不同实例，例如

class Phone: HasValue {
    var val: Int?
}

class Computer: HasValue {
    var val: Int?
}

let iPhone = Phone()
iPhone.val = 10

let iMac = Computer()
iMac.val = 9

merge(iPhone, into: iMac)
print(iMac.val) // Optional(10)

场景 3：参数有泛型

class Box<S>: HasValue {
    var val: S?
}

let boxOfString = Box<String>()
boxOfString.val = "hello world"

let boxOfInt = Box<Int>()
boxOfInt.val = 12

merge(boxOfString, into: boxOfInt) // << compile error

let boxOfWords = Box<String>()
boxOfWords.val = "What a wonderful world"

merge(boxOfString, into: boxOfWords)
print(boxOfWords.val) // Optional("hello world")