Co to jest Swift równoważny z respondsToSelector?

Przeszukałem go, ale nie byłem w stanie dowiedzieć się, jaki jest szybki odpowiednik respondsToSelector:.

Jest to jedyna rzecz, jaką mogłem znaleźć ( szybka alternatywa dla respondsToSelector:), ale nie jest ona zbyt istotna w moim przypadku, ponieważ sprawdza obecność delegata, nie mam delegata, chcę tylko sprawdzić, czy istnieje nowy interfejs API lub nie, gdy działa na urządzeniu, a jeśli nie, powróć do poprzedniej wersji interfejsu API.

Jak wspomniano, w Swift przez większość czasu możesz osiągnąć to, czego potrzebujesz dzięki ?opcjonalnemu operatorowi odwijarki . Pozwala to na wywołanie metody na obiekcie wtedy i tylko wtedy, gdy obiekt istnieje (nie nil) i metoda jest zaimplementowana.

W przypadku, gdy nadal potrzebujesz respondsToSelector:, nadal jest dostępny jako część NSObjectprotokołu.

Jeśli respondsToSelector:w Swift wywołujesz typ Obj-C, to działa tak, jak byś się spodziewał. Jeśli używasz go we własnej klasie Swift, musisz upewnić się, że twoja klasa pochodzi NSObject.

Oto przykład klasy Swift, którą możesz sprawdzić, czy odpowiada na selektor:

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

Ważne jest, aby nie pominąć nazw parametrów. W tym przykładzie nieSelector("sleep::") jest taki sam jak .Selector("sleep:minutes:")

Nie ma prawdziwej wymiany Swift.

Możesz to sprawdzić w następujący sposób:

someObject.someMethod?()

Wywołuje tę metodę someMethodtylko wtedy, gdy jest zdefiniowana na obiekcie, someObjectale można jej używać tylko w przypadku @objcprotokołów, które zadeklarowały metodę jako optional.

Swift jest z natury bezpiecznym językiem, więc za każdym razem, gdy wywołujesz metodę, Swift musi wiedzieć, że metoda istnieje. Sprawdzanie czasu wykonywania nie jest możliwe. Nie można po prostu wywoływać losowych metod na losowych obiektach.

Nawet w Obj-C powinieneś unikać takich rzeczy, gdy jest to możliwe, ponieważ nie działa to dobrze z ARC (ARC wywołuje wtedy ostrzeżenia performSelector:).

Jednak podczas sprawdzania dostępnych interfejsów API nadal możesz używać respondsToSelector:, nawet jeśli Swift, jeśli masz do czynienia z NSObjectinstancjami:

@interface TestA : NSObject

- (void)someMethod;

@end

@implementation TestA

//this triggers a warning

@end   

var a = TestA()

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

Zaktualizuj 20 marca 2017 dla składni Swift 3:

Jeśli nie obchodzi Cię, czy istnieje opcjonalna metoda, po prostu wywołaj delegate?.optionalMethod?()

W przeciwnym razie użycie guardjest prawdopodobnie najlepszym podejściem:

weak var delegate: SomeDelegateWithOptionals?

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

Oryginalna odpowiedź:

Możesz użyć metody „jeśli pozwól”, aby przetestować opcjonalny protokół w następujący sposób:

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

Wygląda na to, że musisz zdefiniować swój protokół jako podprotokę NSObjectProtocol ... wtedy otrzymasz metodę ResponsToSelector

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

zwróć uwagę, że samo podanie @objc nie wystarczyło. Należy również uważać, aby faktyczny delegat był podklasą NSObject - co w Swift może nie być.

Jeśli metoda, którą testujesz, jest zdefiniowana jako opcjonalna metoda w protokole @objc (która brzmi jak twoja sprawa), użyj opcjonalnego wzoru łączenia jako:

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

Gdy metoda jest deklarowana jako zwracana Void, po prostu użyj:

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

Widzieć:

„Metody wywoływania poprzez opcjonalne tworzenie łańcuchów”
Fragment: Apple Inc. „Swift Programming Language”.
iBooks. https://itun.es/us/jEUH0.l

Funkcje są pierwszorzędnymi typami w Swift, dzięki czemu można sprawdzić, czy zaimplementowano opcjonalną funkcję zdefiniowaną w protokole, porównując ją do zera:

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

Dla swift3

Jeśli chcesz tylko wywołać metodę, uruchom poniższy kod.

self.delegate?.method?()

W Swift 2 Apple wprowadził nową funkcję o nazwie API availability checking, która może być zamiennikiem respondsToSelector:metody. Poniższe porównanie fragmentów kodu jest kopiowane z sesji WWDC2015 106 Co nowego w Swift, które moim zdaniem mogą ci pomóc, sprawdź to, jeśli potrzebujesz wiedzieć więcej.

Stare podejście:

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

Lepsze podejście:

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

Dla szybkiego 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)")
    }
}

Obecnie (Swift 2.1) możesz to sprawdzić na 3 sposoby:

1. Korzystanie z respondsToSelector, na które odpowiedział @Erik_at_Digit

2. Używasz „?” odpowiedział @Sulthan

3. I za pomocą as?operatora:

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

Zasadniczo zależy to od tego, co próbujesz osiągnąć:

• Jeśli na przykład logika aplikacji musi wykonać jakąś akcję, a delegat nie jest ustawiony lub wskazany delegat nie wdrożył metody onSuccess () (metoda protokołu), więc opcje 1 i 3 są najlepszym wyborem, chociaż użyłbym opcja 3, która jest szybka.
• Jeśli nie chcesz nic robić, gdy delegowanie jest zerowe lub metoda nie jest zaimplementowana, użyj opcji 2.

Po prostu implementuję to sam w projekcie, patrz kod poniżej. Jak wspomina @Christopher Pickslay, ważne jest, aby pamiętać, że funkcje są pierwszorzędnymi obywatelami i dlatego mogą być traktowane jak zmienne opcjonalne.

@objc protocol ContactDetailsDelegate: class {

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

...

weak var delegate:ContactDetailsDelegate!

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

inna możliwa składnia przez swift ..

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

Gdy zacząłem aktualizować mój stary projekt do Swift 3.2, po prostu musiałem zmienić metodę z

respondsToSelector(selector)

do:

responds(to: selector)

Używam guard let else, więc mogę zrobić pewne rzeczy domyślne, jeśli delegata func nie jest zaimplementowana.

@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:

protokół

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

Obiekt

class SomeObject : NSObject {

weak var delegate:SomeObject?

func delegateMethod() {

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

   }

}

Odpowiednikiem jest? operator:

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

importantMethod zostanie wywołany tylko wtedy, gdy myQuestionableObject istnieje i implementuje go.