¿Cuál es el equivalente Swift de respondsToSelector?

No hay un reemplazo real de Swift.

Puede comprobarlo de la siguiente manera:

someObject.someMethod?()

Esto llama al método someMethod solo si está definido en object someObject pero puede usarlo solo para los protocolos @objc que han declarado el método como optional.

Swift es inherentemente un lenguaje seguro por lo que cada vez que llame a un método Swift tiene que saber que el método está allí. No es posible verificar el tiempo de ejecución. No puedes simplemente llamar a métodos aleatorios en objetos aleatorios.

Incluso en Obj-C debe evitar tales cosas cuando sea posible porque no se juega bien con ARC (ARC luego activa advertencias para performSelector:).

Sin embargo, al verificar las API disponibles, aún puede usar respondsToSelector:, incluso si es Swift, si está tratando con NSObject instancias:

@interface TestA : NSObject

- (void)someMethod;

@end

@implementation TestA

//this triggers a warning

@end   

var a = TestA()

if a.respondsToSelector("someMethod") {
   a.someMethod()
}

Actualización Mar 20, 2017 para Swift 3 sintaxis:

Si no le importa si el método opcional existe, simplemente llame a delegate?.optionalMethod?()

De lo contrario, usar guard es probablemente el mejor enfoque:

weak var delegate: SomeDelegateWithOptionals?

func someMethod() {
    guard let method = delegate?.optionalMethod else {
        // optional not implemented
        alternativeMethod()
        return
    }
    method()
}

Respuesta original:

Puede usar el enfoque "if let" para probar un protocolo facultativo como este:

weak var delegate: SomeDelegateWithOptionals?

func someMethod() {
  if let delegate = delegate {
    if let theMethod = delegate.theOptionalProtocolMethod? {
      theMethod()
      return
    }
  }
  // Reaching here means the delegate doesn't exist or doesn't respond to the optional method
  alternativeMethod()
}

Parece que necesita definir su protocolo como un subprotocolo de NSObjectProtocol ... entonces obtendrá el método respondsToSelector

@objc protocol YourDelegate : NSObjectProtocol
{
    func yourDelegateMethod(passObject: SomeObject)
}

Tenga en cuenta que solo especificar @objc no era suficiente. También debe tener cuidado de que el delegado real sea una subclase de NSObject , lo que en Swift podría no serlo.

Si el método para el que está probando se define como un método opcional en un protocolo @objc (que suena como su caso), entonces use el patrón de encadenamiento opcional como:

if let result = object.method?(args) {
  /* method exists, result assigned, use result */
}
else { ... }

Cuando el método es declare como returning Void, simplemente use:

if object.method?(args) { ... }

Véase:

"Métodos De Llamada Mediante Encadenamiento Opcional"
Extracto De: Apple Inc. "The Swift Programming Language."
iBooks. https://itun.es/us/jEUH0.l

Las funciones son tipos de primera clase en Swift, por lo que puede verificar si una función opcional definida en un protocolo se ha implementado comparándola con nil:

if (someObject.someMethod != nil) {
    someObject.someMethod!(someArgument)
} else {
    // do something else
}

En Swift 2,Apple introdujo una nueva característica llamada API availability checking, que podría ser un reemplazo para el método respondsToSelector:.La siguiente comparación de fragmentos de código se copia de la sesión WWDC2015 106 Qué hay de nuevo en Swift que pensé que podría ayudarlo,por favor compruébelo si necesita saber más.

El Viejo Enfoque:

@IBOutlet var dropButton: NSButton!
override func awakeFromNib() {
    if dropButton.respondsToSelector("setSpringLoaded:") {
        dropButton.springLoaded = true
    }
}

El Mejor Enfoque:

@IBOutlet var dropButton: NSButton!
override func awakeFromNib() {
    if #available(OSX 10.10.3, *) {
        dropButton.springLoaded = true
    }
}

Para swift3

Si solo desea llamar al método, ejecute el código a continuación.

self.delegate?.method?()

Actualmente (Swift 2.1) se puede comprobar usando 3 maneras:

1. Usando respondsToSelector respondido por @Erik_at_Digit

2. Usando '?' contestado por @Sulthan

3. Y usando el operador as?:

   if let delegateMe = self.delegate as? YourCustomViewController
   {
      delegateMe.onSuccess()
   }
   

Básicamente depende de lo que usted está tratando de lograr:

• Si, por ejemplo, la lógica de la aplicación necesita realizar alguna acción y el delegado no está configurado o el delegado apuntado no implementó el método onuccess() (método de protocolo) así que la opción 1 y 3 son la mejor opción, aunque usaría la opción 3, que es Rápida.
• Si no desea hacer nada cuando delegate es nil o el método no está implementado, use la opción 2.

Para swift 3.0

import UIKit

@objc protocol ADelegate : NSObjectProtocol {

    @objc optional func hi1()
    @objc optional func hi2(message1:String, message2:String)
}

class SomeObject : NSObject {

    weak var delegate:ADelegate?

    func run() {

        // single method
        if let methodHi1 = delegate?.hi1 {
            methodHi1()
        } else {
            print("fail h1")
        }

        // multiple parameters
        if let methodHi2 = delegate?.hi2 {
            methodHi2("superman", "batman")
        } else {
            print("fail h2")
        }
    }
}

class ViewController: UIViewController, ADelegate {

    let someObject = SomeObject()

    override func viewDidLoad() {
        super.viewDidLoad()

        someObject.delegate = self
        someObject.run()
    }

    // MARK: ADelegate
    func hi1() {

        print("Hi")
    }

    func hi2(message1: String, message2: String) {

        print("Hi \(message1) \(message2)")
    }
}

Acabo de implementar esto yo mismo en un proyecto, ver el código a continuación. Como menciona @ Christopher Pickslay, es importante recordar que las funciones son ciudadanos de primera clase y, por lo tanto, pueden tratarse como variables opcionales.

@objc protocol ContactDetailsDelegate: class {

    optional func deleteContact(contact: Contact) -> NSError?
}

...

weak var delegate:ContactDetailsDelegate!

if let deleteContact = delegate.deleteContact {
    deleteContact(contact)
}

Otra posible sintaxis de swift..

 if let delegate = self.delegate, method = delegate.somemethod{
        method()
    }

Cuando comencé a actualizar mi antiguo proyecto a Swift 3.2, solo necesitaba cambiar el método de

respondsToSelector(selector)

A:

responds(to: selector)

Utilizo guard let else, por lo que puede hacer algunas cosas predeterminadas si el func delegado no está implementado.

@objc protocol ViewController2Delegate: NSObjectProtocol {

    optional func viewController2(controller: ViewController2, didSomethingWithStringAndReturnVoid string: String)

    optional func viewController2(controller: ViewController2, didSomethingWithStringAndReturnString string: String) -> String
}

class ViewController2: UIViewController {

    weak var delegate: ViewController2Delegate?        

    @IBAction func onVoidButtonClicked(sender: AnyObject){

        if (delegate != nil && delegate!.respondsToSelector(Selector("viewController2:didSomethingWithStringAndReturnVoid:"))) {
            NSLog("ReturnVoid is implemented")

            delegate!.viewController2!(self, didSomethingWithStringAndReturnVoid: "dummy")
        }
        else{
            NSLog("ReturnVoid is not implemented")
            // Do something by default
        }
    }

    @IBAction func onStringButtonClicked(sender: AnyObject){

        guard let result = delegate?.viewController2?(self, didSomethingWithStringAndReturnString: "dummy") else {
            NSLog("ReturnString is not implemented")
            // Do something by default
            return
        }

        NSLog("ReturnString is implemented with result: \(result)")
    }
}

Swift 3:

Protocolo

@objc protocol SomeDelegate {
    @objc optional func method()
}

Objeto

class SomeObject : NSObject {

weak var delegate:SomeObject?

func delegateMethod() {

     if let delegateMethod = delegate?.method{
         delegateMethod()
     }else {
        //Failed
     }

   }

}

El equivalente es el ? operador:

var value: NSNumber? = myQuestionableObject?.importantMethod()

ImportantMethod solo se llamará si myQuestionableObject existe y lo implementa.