检查Swift类是否符合协议并实现可选函数？

Question

我正在用Swift编写一个帮助函数，用于SpriteKit游戏中，它将检查是否正确设置了碰撞滞留。

我想检查我的GameScene是否实现了协议SKPhysicsContactDeletegate，并且还包含了didBeginContact函数。

我有以下代码，在Xcode的自动完成的帮助下编写的：

    if GameScene(conformsToProtocol(SKPhysicsContactDelegate)) {
        if GameScene(respondsToSelector(didBeginContact(SKPhysicsContact))) {
            print("Self implements SKPhysicsContactDelegate and didBeginContact appears to be present")
        }
    }

然后Xcode抱怨我的conformsToProtocol，抱怨

‘参数标签'(_:)’不匹配任何可用的重载‘

却不知道该怎么解决。它还反对respondsToSelector，声明

‘无法将类型的值(SKPhysicsContact).Type’(又名'SKPhysicsContact.Type')转换为预期的参数类型'SKPhysicsContact‘

如何检查我的GameScene是否符合此协议并实现此功能？

编辑:这是我基于答案的代码：

if GameScene.self is SKPhysicsContactDelegate {
    print("Yes it's a delegate")
}

输出：Yes it's a delegate

let yy = (GameScene.self as? SKPhysicsContactDelegate)?.didBeginContact
print("yy is \(yy)")

输出：yy is nil

if (GameScene.self as? SKPhysicsContactDelegate)?.didBeginContact != nil {
    print("Yes it's a delegate and the function is there")
}

没有输出。

Answer 1

你还在想目标C，拥抱斯威夫特！

假设您的协议如下所示：

@objc protocol SKPhysicsContactDelegate {
    optional func didBeginContact()
}

试试这个：

if let delegate = gameScene as? SKPhysicsContactDelegate {
    delegate.didBeginContact?()
}

或者一条衬里：

(gameScene as? SKPhysicsContactDelegate)?.didBeginContact?()

注意调用中方法名称之后的?吗？这是因为该方法是可选的，如果对象不实现该方法，则不会调用该方法。如果对象不符合SKPhysicsContactDeletegate协议，则不会执行SKPhysicsContactDeletegate分支。

不调用检查方法存在性

若要在调用之前检查方法本身是否存在，只需省略方法调用以获得对该方法的引用，并像检查任何其他变量一样检查它：

if let method = (gameScene as? SKPhysicsContactDelegate)?.didBeginContact {
    print("gameScene conforms to SKPhysicsContactDelegate and implements didBeginContact")
    // Call it later whenever you want
    method()
}

如果您不需要稍后调用它，只需检查一下nil

if (gameScene as? SKPhysicsContactDelegate)?.didBeginContact != nil {
    print("gameScene conforms to SKPhysicsContactDelegate and implements didBeginContact")
}

检查静态方法

检查optional static方法使用相同的方法，但需要类对象而不是类的实例：

if (GameScene.self as? OptionalProtocol.Type)?.staticMethod != nil {
    print("gameScene conforms to OptionalProtocol and implements staticMethod")
}

请注意GameScene.self用于获取对象类型和<protocol>.Type，以将其转换为协议类而不是协议实例。

全样本

附上游乐场、斯威夫特脚本或任何在线Swift编译器的完整样本

import Foundation

@objc protocol OptionalProtocol {
    optional func instanceMethod()
    optional static func staticMethod()
}

class Nothing {}
class Something: OptionalProtocol {}
class Bar: NSObject, OptionalProtocol {
    func instanceMethod() {
        print("Instance method")
    }
}
class Foo: NSObject, OptionalProtocol {
    static func staticMethod() {
        print("Static method")
    }
}

// Cast instances to 'Any' and classes to 'AnyClass'
let nothing: Any = Nothing()
let nothingClass: AnyClass = Nothing.self
let something: Any = Something()
let somethingClass: AnyClass = Something.self
let bar: Any = Bar()
let barClass: AnyClass = Bar.self
let foo: Any = Foo()
let fooClass: AnyClass = Foo.self

nothing is OptionalProtocol // false
(nothing as? OptionalProtocol)?.instanceMethod != nil // false
(nothing as? OptionalProtocol)?.instanceMethod?() // Does nothing
(nothingClass as? OptionalProtocol.Type)?.staticMethod != nil // false
(nothingClass as? OptionalProtocol.Type)?.staticMethod?() != nil // Does nothing

something is OptionalProtocol // true
(something as? OptionalProtocol)?.instanceMethod != nil // false
(something as? OptionalProtocol)?.instanceMethod?() // Does nothing
(somethingClass as? OptionalProtocol.Type)?.staticMethod != nil // false
(somethingClass as? OptionalProtocol.Type)?.staticMethod?() != nil // Does nothing

bar is OptionalProtocol // true
(bar as? OptionalProtocol)?.instanceMethod != nil // true
(bar as? OptionalProtocol)?.instanceMethod?() // Prints 'Instance method'
(barClass as? OptionalProtocol.Type)?.staticMethod != nil // false
(barClass as? OptionalProtocol.Type)?.staticMethod?() != nil // Does nothing

foo is OptionalProtocol // true
(foo as? OptionalProtocol)?.instanceMethod != nil // false
(foo as? OptionalProtocol)?.instanceMethod?() // Does nothing
(fooClass as? OptionalProtocol.Type)?.staticMethod != nil // true
(fooClass as? OptionalProtocol.Type)?.staticMethod?() != nil // Prints 'Static method'

Answer 2

respondsToSelector失败，因为它需要一个SKPhysicsContact实例，而不是SKPhysicsContact.type实例。

要检查对象是否实现了接口，可以使用is。例如：

protocol Test {
    func foo();
}

class TestImpl : Test {
    func foo() {
        print("bar")
    }
}

let a = TestImpl()
let b = String()
print(a is Test) // true
print(b is Test) // false