如果数组中的项目存在，则替换它的简单方法，如果不存在则追加它

Question

斯威夫特 4.2

我有多个函数可以替换数组中的对象或结构（如果存在），如果不存在，则添加它。

func updateFruit(_ fruit: Fruit)
{
    if let idx = fruitArray.firstIndex(where: { $0.id == fruit.id })
    {
        fruitArray[idx] = fruit
    }
    else
    {
        fruitArray.append(fruit)
    }
}

显然我可以把它变成 Array 的扩展：

extension Array
{
    mutating func replaceOrAppend(_ item: Element, whereFirstIndex predicate: (Element) -> Bool)
    {
        if let idx = self.firstIndex(where: predicate)
        {
            self[idx] = item
        }
        else
        {
            append(item)
        }
    }
}

但是，有没有更简单、更容易的表达方式？最好使用闭包或内置函数。

注意：当前的实现不允许使用集合。

Answer 1

鉴于您的用例，您总是在检查$0.<prop> == newthing.<prop>，您可以通过添加以下内容进一步提升：

mutating func replaceOrAppend<Value>(_ item: Element, 
                                     firstMatchingKeyPath keyPath: KeyPath<Element, Value>)
    where Value: Equatable
{
    let itemValue = item[keyPath: keyPath]
    replaceOrAppend(item, whereFirstIndex: { $0[keyPath: keyPath] == itemValue })
}

然后你可以像这样使用它：

struct Student {
    let id: Int
    let name: String
}

let alice0 = Student(id: 0, name: "alice")
let alice1 = Student(id: 1, name: "alice")
let bob = Student(id: 0, name: "bob")

var array = [alice0]

array.replaceOrAppend(alice1, firstMatchingKeyPath: \.name) // [alice1]
array.replaceOrAppend(bob, firstMatchingKeyPath: \.name)    // [alice1, bob]

当然，如果你经常这样做，你可以不断提升。

protocol Identifiable {
    var id: Int { get }
}

extension Student: Identifiable {}

extension Array where Element: Identifiable {
    mutating func replaceOrAppendFirstMatchingID(_ item: Element)
    {
        replaceOrAppend(item, firstMatchingKeyPath: \.id)
    }
}

array.replaceOrAppendFirstMatchingID(alice0) // [alice1, alice0]

Answer 2

假设您的类型是 Equatable，这是一个通用扩展：

extension RangeReplaceableCollection where Element: Equatable {

    mutating func addOrReplace(_ element: Element) {
        if let index = self.firstIndex(of: element) {
            self.replaceSubrange(index...index, with: [element])
        }
        else {
            self.append(element)
        }
    }
}

不过，请记住，我（和您的）函数只会替换 一个 匹配项。

完整的工作操场测试：

Answer 3

我可以建议使用replaceValue 创建protocol Replacable，这将表示我们可以用来枚举对象的标识符。

protocol Replacable {
    var replaceValue: Int { get }
}

现在我们可以为Array 创建扩展，但现在我们可以像这样从示例代码中删除谓词

extension Array where Element: Replacable {
    mutating func replaceOrAppend(_ item: Element) {
        if let idx = self.firstIndex(where: { $0.replaceValue == item.replaceValue }) {
            self[idx] = item
        }
        else {
            append(item)
        }
    }
}

由于Set 不是有序集合，我们可以简单地删除对象，如果集合包含它并插入新值

extension Set where Element: Replacable {
    mutating func replaceOrAppend(_ item: Element) {
        if let existItem = self.first(where: { $0.replaceValue == item.replaceValue }) {
            self.remove(existItem)
        }
        self.insert(item)
    }
}