Что такое Swift-эквивалент responsedsToSelector?

Я погуглил, но не смог выяснить, что такое быстрый эквивалент respondsToSelector:.

Это единственное, что я могу найти ( альтернатива Swift для responsedsToSelector:), но это не слишком уместно в моем случае, так как он проверяет наличие делегата, у меня нет делегата, я просто хочу проверить, существует ли новый API или нет при запуске на устройстве и, если нет, вернуться к предыдущей версии API.

Как уже упоминалось, в Swift большую часть времени вы можете достичь того, что вам нужно, с помощью ?дополнительного оператора распаковки . Это позволяет вам вызывать метод объекта тогда и только тогда, когда объект существует (не существует nil) и метод реализован.

В случае, когда вам все еще нужно respondsToSelector:, это все еще там как часть NSObjectпротокола.

Если вы вызываете respondsToSelector:тип Obj-C в Swift, то он работает так же, как и ожидалось. Если вы используете его в своем собственном классе Swift, вам необходимо убедиться, что ваш класс является производным от него NSObject.

Вот пример класса Swift, который вы можете проверить, реагирует ли он на селектор:

class Worker : NSObject
{
    func work() { }
    func eat(food: AnyObject) { }
    func sleep(hours: Int, minutes: Int) { }
}

let worker = Worker()

let canWork = worker.respondsToSelector(Selector("work"))   // true
let canEat = worker.respondsToSelector(Selector("eat:"))    // true
let canSleep = worker.respondsToSelector(Selector("sleep:minutes:"))    // true
let canQuit = worker.respondsToSelector(Selector("quit"))   // false

Важно, чтобы вы не пропускали имена параметров. В этом примере Selector("sleep::")это не то же самое, что Selector("sleep:minutes:").

Там нет реальной замены Swift.

Вы можете проверить следующим образом:

someObject.someMethod?()

Это вызывает метод, someMethodтолько если он определен для объекта, someObjectно вы можете использовать его только для @objcпротоколов, которые объявили метод как optional.

Swift по своей природе является безопасным языком, поэтому каждый раз, когда вы вызываете метод, Swift должен знать, что этот метод существует. Проверка во время выполнения невозможна. Вы не можете просто вызывать случайные методы для случайных объектов.

Даже в Obj-C вы должны избегать подобных вещей, когда это возможно, потому что это не очень хорошо работает с ARC (ARC затем вызывает предупреждения performSelector:).

Однако при проверке доступных API вы все равно можете использовать respondsToSelector:, даже если Swift, если вы имеете дело с NSObjectэкземплярами:

@interface TestA : NSObject

- (void)someMethod;

@end

@implementation TestA

//this triggers a warning

@end   

var a = TestA()

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

Обновление 20 марта 2017 года для синтаксиса Swift 3:

Если вам все равно, существует ли необязательный метод, просто вызовите delegate?.optionalMethod?()

В противном случае, использование guard, вероятно, лучший подход:

weak var delegate: SomeDelegateWithOptionals?

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

Оригинальный ответ:

Вы можете использовать подход «если позволите», чтобы проверить дополнительный протокол, подобный этому:

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()
}

Кажется, вам нужно определить свой протокол как подпроток NSObjectProtocol ... тогда вы получите метод responsedsToSelector

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

обратите внимание, что только указание @objc было недостаточно. Вы также должны быть осторожны, что фактический делегат является подклассом NSObject - чего в Swift может и не быть.

Если метод, который вы тестируете, определен как необязательный метод в протоколе @objc (который звучит как ваш случай), то используйте дополнительный шаблон цепочки как:

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

Когда метод объявлен как возвращаемый Void, просто используйте:

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

Видеть:

«Вызов методов посредством необязательного связывания».
Отрывок из: Apple Inc. «Язык программирования Swift».
интерактивные книги. https://itun.es/us/jEUH0.l

Функции являются первоклассными типами в Swift, поэтому вы можете проверить, была ли реализована дополнительная функция, определенная в протоколе, сравнив ее с nil:

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

Для swift3

Если вы просто хотите вызвать метод, запустите код ниже.

self.delegate?.method?()

В Swift 2 Apple представила новую функцию под названием API availability checking, которая может заменить respondsToSelector:метод. Следующее сравнение фрагментов кода скопировано из сеанса 106 WWDC2015 « Что нового в Swift», которое, как я думал, может вам помочь, пожалуйста, проверьте его, если вам нужно узнать больше.

Старый подход:

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

Лучший подход:

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

Для 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)")
    }
}

В настоящее время (Swift 2.1) вы можете проверить это тремя способами:

1. Использование respondsToSelector ответил @Erik_at_Digit

2. Используя '?' ответил @Sulthan

3. И с помощью as?оператора:

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

В основном это зависит от того, чего вы пытаетесь достичь:

• Например, если вашей логике приложения необходимо выполнить какое-либо действие, а делегат не установлен, или указанный делегат не реализовал метод onSuccess () (метод протокола), то варианты 1 и 3 - лучший выбор, хотя я бы использовал вариант 3, который является быстрым способом.
• Если вы не хотите ничего делать, когда делегат равен nil или метод не реализован, используйте опцию 2.

Я просто сам реализую это в проекте, см. Код ниже. Как упоминает @Christopher Pickslay, важно помнить, что функции являются гражданами первого класса и поэтому могут рассматриваться как необязательные переменные.

@objc protocol ContactDetailsDelegate: class {

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

...

weak var delegate:ContactDetailsDelegate!

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

другой возможный синтаксис по быстрому ..

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

Когда я начал обновлять свой старый проект до Swift 3.2, мне просто нужно было изменить метод с

respondsToSelector(selector)

чтобы:

responds(to: selector)

Я использую guard let else, так что это может сделать некоторые вещи по умолчанию, если функция делегата не реализована.

@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)")
    }
}

Свифт 3:

протокол

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

объект

class SomeObject : NSObject {

weak var delegate:SomeObject?

func delegateMethod() {

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

   }

}

Эквивалент? оператор:

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

важный метод будет вызываться только в том случае, если myQuestionableObject существует и реализует его.