Swift：子类 NSMutableArray

Question

我正在尝试在 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 将 Arrays 连接到 NSArrays。但是，我需要将对 Swift 数组的引用传递给一些接受 NSMutableArray 并可能对数组进行更新的 Objective-C 代码。

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

Answer 1

你是aware吗：

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

特别是：

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

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

免责声明

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

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

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

编辑

看完这篇answer

我决定检查NSMutableArraydocumentation：

重写方法

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 并没有崩溃
• 在add(_:) 中调用super.add(_:) 将触发insert(_:at:)
• NSMutableArray 与 ExpressibleByArrayLiteral 的一致性可能是在扩展中编写的（这很有意义，因为 NSMutableArray 是一个 Objective-C 类），因此覆盖 init() forces 你要覆盖 init(arrayLitteral:) 并且编译器会说 不支持在扩展中覆盖声明。 ：

自动初始化器继承

规则 1

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

规则 2

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

Answer 2

我们一般应该遵循开闭原则，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 的Objective-C 例程而对NSMutableArray 进行子类化。只有在基准测试（或其他考虑）认为绝对必要时，我才会这样做。

---

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

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, 2, 3, 42

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

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