Swift：子类 NSMutableArray 免责声明编辑有趣的事实

如何解决Swift：子类 NSMutableArray 免责声明编辑有趣的事实

我正在尝试在 Swift 中继承 NSMutableArray 以将 Swift 数组的桥接功能提供给某些旧的 Objective-C 代码库。但是，我找不到功能示例，到目前为止我所有的尝试都失败了。这是我得到的最接近功能示例的示例：

import UIKit

class MyArray: NSMutableArray {

    var array: [Int]?

// Adding an initializer triggers the error: 'required' initializer 'init(arrayLiteral:)' must be provided by subclass of 'NSArray'
//    override init() {
//        self.array = []
//        super.init()
//    }

    static func makeArray() -> MyArray {
        let array = MyArray()
        array.array = []
        return array
    }

    override var count: Int {
        get {
            if let count = array?.count {
                return count
            }

            return 0
        }
    }

    override func insert(_ anObject: Any,at index: Int) {
        print("insert called")
    }

    override func removeObject(at index: Int) {
        print("removeObject called")
    }

    override func add(_ anObject: Any) {
        print("Trying to add \(anObject)")
        if let newInt = anObject as? Int {
            array?.append(newInt)
        }
    }

    override func removeLastObject() {
        print("removeLastObject called")
    }

    override func replaceObject(at index: Int,with anObject: Any) {
        print("replaceObject called")
    }
}

func append42(array: NSMutableArray) {
    array.add(42)
}

let myArray = MyArray.makeArray()

print("Before: \(myArray.array)")
myArray.array?.append(42)
// The following two lines generate a SIGABRT
//myArray.add(42)
//append42(array: myArray)
print("After: \(myArray.array)")

但是，使用 add 方法总是会触发 SIGABRT。我在 Catalina 上使用 XCode 12.4。

编辑（澄清）：我知道 Swift 将 Array 连接到 NSArray。但是，我需要将 Swift 数组的引用传递给一些接受 NSMutableArray 并可能对数组进行更新的 Objective-C 代码。

本质上，我将一些 Swift 代码添加到现有项目中，我想在新代码中使用 Swift 类型化数组，但我仍然将这些数组传递给旧代码。我知道我可以制作 Swift 数组的 NSMutableArray 副本，将此副本传递给旧代码，然后将其复制回 Swift 数组，但它相当复杂且难以维护。我试图做的是将对 Swift 数组的引用封装到“NSMutableArray”子类中，以便我可以透明地将此子类与遗留代码一起使用。

解决方法

您是否aware：

导入 Foundation 框架时，Swift 覆盖层为许多桥接引用类型提供值类型。许多其他类型被重命名或嵌套以阐明关系。

特别是：

包含不可变和可变子类（如 NSArray 和 NSMutableArray）的类簇被桥接到单个值类型。

所以你可以用 Array 代替 NSArray，如果你想要一个 NSMutableArray 也是一个 Swift Array（但是一个 var）。 同样的事情适用于 Dictionary 和 NSDictionary。

免责声明

我可能不会在生产代码中使用它，虽然不禁止对 NSArray 和 NSMutableArray 进行子化，但文档说：

通常没有理由将 NSMutableArray 子类化。

这应该足以考虑另一个解决方案恕我直言

编辑

阅读完这篇answer

我决定检查NSMutableArray documentation：

覆盖方法

NSMutableArray 定义了五个原始方法：

插入(_:at:)

removeObject(at:)

添加(_:)

removeLastObject()

replaceObject(at:with:)

在子类中，您必须覆盖所有这些方法。您还必须覆盖 NSArray 类的原始方法。

所以我也检查了 NSArray documentation：

NSArray 的任何子类都必须覆盖原始实例方法 count 和 object(at:)。这些方法必须在您为集合元素提供的后备存储上运行。对于这个后备存储，您可以使用静态数组、标准 NSArray 对象或其他一些数据类型或机制。您还可以选择部分或完全覆盖您想要为其提供替代实现的任何其他 NSArray 方法。

现在，使用：

@objc class MyArray: NSMutableArray {

    var array: [Int] = []
    static func makeArray() -> MyArray {
        let array = MyArray()
        array.array = []
        return array
    }

    override var count: Int {
        array.count
    }
    
    override func object(at index: Int) -> Any {
        array[index]
    }

    override func insert(_ anObject: Any,at index: Int) {
        print("insert called")
        if let newInt = anObject as? Int {
            array.insert(newInt,at: index)
        }
    }

    override func removeObject(at index: Int) {
        array.remove(at: index)
        print("removeObject called")
    }

    override func add(_ anObject: Any) {
        print("Trying to add \(anObject)")
        if let newInt = anObject as? Int {
            array.append(newInt)
        }
    }
}

func append42(array: NSMutableArray) {
    array.add(42)
}

我有：

let myArray = MyArray.makeArray()

print("Before: \(myArray.array)")
myArray.array.append(42) // [42]
// The following two lines generate a SIGABRT
myArray.add(42) // [42,42]
append42(array: myArray)
print("After: \(myArray.array)")

// Before: []
// Trying to add 42
// Trying to add 42
// After: [42,42,42]

有趣的事实

• 我在操场上尝试了您的代码并重现了崩溃。我试过 XCTestCase 并没有崩溃
• 在super.add(_:)中调用add(_:)会触发insert(_:at:)
• NSMutableArray 与 ExpressibleByArrayLiteral 的一致性可能写在扩展中（这很有意义，因为 NSMutableArray 是一个 Objective-C 类），因此覆盖 init() {{3 }} 你覆盖 init(arrayLitteral:) 并且编译器说不支持覆盖扩展中的声明。 ：

自动初始化器继承

规则 1

如果您的子类没有定义任何指定的初始化器，它会自动继承其所有超类指定的初始化器。

规则 2

如果您的子类提供了其所有超类指定初始值设定项的实现——或者按照规则 1 继承它们，或者通过提供自定义实现作为其定义的一部分——那么它会自动继承所有超类便利初始值设定项。

,

我们一般应该遵循开闭原则，OCP，即类对扩展开放，对修改关闭。这种对 NSMutableArray 进行子类化并替换一些关键方法的尝试违反了 OCP。很可能会表现出各种奇怪的行为。

如果您真的想要子类化，您将需要覆盖 NSArray 和 NSMutableArray 的所有原始方法。从理论上讲，您可以检查您的 Objective-C 代码并查看它调用的方法，但这是一种非常脆弱的方法。我不建议这种模式。

就我个人而言，如果我试图与一些需要 NSMutableArray 的 Objective-C 代码集成，我会坚持使用 Swift 数组并在调用我的 Objective-C 库之前创建一个 NSMutableArray，然后将其复制回数组（与 Swift 数组的值语义一致）。

考虑：

@implementation Foo
- (void)bar:(NSMutableArray *)array {
    [array addObject:@42];
}
@end

我会为 Swift Array 填充这个：

extension Foo {
    func bar(_ values: inout [Int]) {
        let array = NSMutableArray(array: values)
        bar(array)
        values = array as! [Int]
    }
}

然后我可以这样做：

var values = [1,2]
values.append(3)
let foo = Foo()
foo.bar(&values)
print(values)                       // 1,2,3,42

但我会避免子类化 NSMutableArray，因为我碰巧调用了一些使用 NSMutableArray 的 Objective-C 例程。只有在基准测试（或其他考虑）认为绝对必要的情况下，我才会这样做。

---

让我们假设您绝对需要坚持使用 NSMutableArray（例如，您有数百万条记录并且不断调用这个 Objective-C 例程）。在那种情况下，我仍然不建议子类化 NSMutableArray，而是直接在我的 Swift 代码中使用 NSMutableArray。如果我想从我的 Int 中检索 NSMutableArray 值并且不想到处投射，我会向 extension 添加一个 NSMutableArray：

extension NSMutableArray {
    func append(integer value: Int) {
        add(value)
    }

    func intValue(at index: Int) -> Int {
        return self[index] as! Int
    }
}

然后你可以这样做：

let values: NSMutableArray = [1,2]
values.append(integer: 3)

let foo = Foo()
foo.bar(values)

print(values)                       // 1,42

let value = values.intValue(at: 3)
print(value)                        // This is `Int` value of 42

现在，我知道这不是您希望的答案，即您不想“失去 Swift 类型化 Array”的好处，同时仍然使用此 Objective-C 遗留代码。但至少这两种方法可以为您提供类型安全的整数值设置和检索。