@selector () in Swift?

Sto cercando di creare un NSTimerin Swiftma ho qualche problema.

NSTimer(timeInterval: 1, target: self, selector: test(), userInfo: nil, repeats: true)

test() è una funzione nella stessa classe.

Viene visualizzato un errore nell'editor:

Impossibile trovare un sovraccarico per "init" che accetta gli argomenti forniti

Quando cambio selector: test()per selector: nille scompare errore.

Ho provato:

• selector: test()
• selector: test
• selector: Selector(test())

Ma nulla funziona e non riesco a trovare una soluzione nei riferimenti.

Swift stesso non utilizza i selettori: diversi modelli di design che in Objective-C utilizzano i selettori funzionano in modo diverso in Swift. (Ad esempio, utilizzare il concatenamento facoltativo su tipi di protocollo o is/ astest anziché respondsToSelector:e utilizzare chiusure ovunque possibile anziché performSelector:per una migliore sicurezza di tipo / memoria.)

Esistono tuttavia alcune importanti API basate su ObjC che utilizzano selettori, inclusi i timer e il modello di destinazione / azione. Swift fornisce il Selectortipo per lavorare con questi. (Swift lo utilizza automaticamente al posto del SELtipo di ObjC .)

In Swift 2.2 (Xcode 7.3) e versioni successive (inclusi Swift 3 / Xcode 8 e Swift 4 / Xcode 9):

Puoi costruire un Selectorda un tipo di funzione Swift usando l' #selectorespressione.

let timer = Timer(timeInterval: 1, target: object,
                  selector: #selector(MyClass.test),
                  userInfo: nil, repeats: false)
button.addTarget(object, action: #selector(MyClass.buttonTapped),
                 for: .touchUpInside)
view.perform(#selector(UIView.insertSubview(_:aboveSubview:)),
             with: button, with: otherButton)

La cosa grandiosa di questo approccio? Il compilatore Swift verifica il riferimento di una funzione, pertanto è possibile utilizzare l' #selectorespressione solo con coppie classe / metodo effettivamente esistenti e idonee all'uso come selettori (vedere "Disponibilità del selettore" di seguito). Sei anche libero di rendere il riferimento alla tua funzione solo specifico di cui hai bisogno, secondo le regole di Swift 2.2+ per la denominazione del tipo di funzione .

(Questo è in realtà un miglioramento rispetto alla @selector()direttiva di ObjC , perché il -Wundeclared-selectorcontrollo del compilatore verifica solo l'esistenza del selettore denominato. Il riferimento alla funzione Swift che passi per #selectorverificare l'esistenza, l'appartenenza a una classe e la firma del tipo.)

Ci sono un paio di avvertenze extra per i riferimenti di funzione che passi #selectorall'espressione:

• Più funzioni con lo stesso nome di base possono essere differenziate dalle loro etichette dei parametri utilizzando la sintassi di cui sopra per i riferimenti di funzione (ad es. insertSubview(_:at:)Vs insertSubview(_:aboveSubview:)). Ma se una funzione non ha parametri, l'unico modo per chiarire l'ambiguità è usare un ascast con la firma del tipo di funzione (ad es. foo as () -> ()Vs foo(_:)).
• Esiste una sintassi speciale per le coppie getter / setter di proprietà in Swift 3.0+. Ad esempio, dato un var foo: Int, puoi usare #selector(getter: MyClass.foo)o #selector(setter: MyClass.foo).

Note generali:

Casi in cui #selectornon funziona e denominazione: a volte non si dispone di un riferimento di funzione con cui creare un selettore (ad esempio, con metodi registrati dinamicamente nel runtime di ObjC). In tal caso, puoi costruire un Selectorda una stringa: ad esempio Selector("dynamicMethod:"), anche se perdi il controllo di validità del compilatore. Quando lo fai, devi seguire le regole di denominazione di ObjC, inclusi i due punti ( :) per ciascun parametro.

Disponibilità del selettore: il metodo a cui fa riferimento il selettore deve essere esposto al runtime ObjC. In Swift 4, ogni metodo esposto a ObjC deve avere la sua dichiarazione preceduta dall'attributo @objc. (Nelle versioni precedenti hai ottenuto l'attributo gratuitamente in alcuni casi, ma ora devi dichiararlo esplicitamente.)

Ricorda che anche i privatesimboli non sono esposti al runtime: il tuo metodo deve avere almeno internalvisibilità.

Percorsi chiave: sono correlati ma non uguali ai selettori. C'è una sintassi speciale anche per questi in Swift 3: ad es chris.valueForKeyPath(#keyPath(Person.friends.firstName)). Vedere SE-0062 per i dettagli. E ancora più contenuti KeyPathin Swift 4 , quindi assicurati di utilizzare l'API basata su KeyPath corretta anziché i selettori, se appropriato.

Puoi leggere ulteriori informazioni sui selettori in Interazione con le API di Objective-C in Uso di Swift con Cocoa e Objective-C .

^{Nota: prima di Swift 2.2, Selectorconforme StringLiteralConvertible, quindi potresti trovare il vecchio codice in cui le stringhe nude vengono passate alle API che accettano selettori. Ti consigliamo di eseguire "Converti in sintassi Swift corrente" in Xcode per ottenere quelli che utilizzano #selector.}

Ecco un breve esempio su come utilizzare la Selectorclasse su Swift:

override func viewDidLoad() {
    super.viewDidLoad()

    var rightButton = UIBarButtonItem(title: "Title", style: UIBarButtonItemStyle.Plain, target: self, action: Selector("method"))
    self.navigationItem.rightBarButtonItem = rightButton
}

func method() {
    // Something cool here   
}

Nota che se il metodo passato come stringa non funziona, non funzionerà in fase di esecuzione, non durante la compilazione e causerà l'arresto anomalo dell'app. Stai attento

Inoltre, se la tua classe (Swift) non discende da una classe Objective-C, allora devi avere i due punti alla fine della stringa del nome del metodo target e devi usare la proprietà @objc con il tuo metodo target, ad es.

var rightButton = UIBarButtonItem(title: "Title", style: UIBarButtonItemStyle.Plain, target: self, action: Selector("method"))

@objc func method() {
    // Something cool here   
} 

in caso contrario verrà visualizzato un errore "Selettore non riconosciuto" in fase di esecuzione.

Swift 2.2+ e Swift 3 Update

Utilizzare la nuova #selectorespressione, che elimina la necessità di utilizzare letterali di stringa rendendo l'utilizzo meno soggetto a errori. Per riferimento:

Selector("keyboardDidHide:")

diventa

#selector(keyboardDidHide(_:))

Vedi anche: proposta Swift Evolution

Nota (Swift 4.0):

Se si utilizza, #selectorè necessario contrassegnare la funzione come@objc

Esempio:

@objc func something(_ sender: UIButton)

Swift 4.0

crei il Selettore come sotto.

1.aggiungere l'evento a un pulsante come:

button.addTarget(self, action: #selector(clickedButton(sender:)), for: UIControlEvents.touchUpInside)

e la funzione sarà come di seguito:

@objc func clickedButton(sender: AnyObject) {

}

Per i futuri lettori, ho scoperto di aver riscontrato un problema e di aver riscontrato un unrecognised selector sent to instanceerrore causato contrassegnando l'obiettivo funccome privato.

Il func DEVE essere pubblicamente visibili di essere chiamato da un oggetto con un riferimento a un selettore.

Nel caso in cui qualcun altro abbia lo stesso problema che ho avuto con NSTimer in cui nessuna delle altre risposte ha risolto il problema, è davvero importante menzionare che, se si utilizza una classe che non eredita da NSObject direttamente o in profondità nella gerarchia ( ad es. file rapidi creati manualmente), nessuna delle altre risposte funzionerà anche se specificato come segue:

let timer = NSTimer(timeInterval: 1, target: self, selector: "test", 
                    userInfo: nil, repeats: false)
func test () {}

Senza cambiare nient'altro che il fatto di ereditare la classe da NSObject, ho smesso di ottenere l'errore "Selettore non riconosciuto" e ho fatto funzionare la mia logica come previsto.

Se si desidera passare un parametro alla funzione da NSTimer, ecco la soluzione:

var somethingToPass = "It worked"

let timer = NSTimer.scheduledTimerWithTimeInterval(0.01, target: self, selector: "tester:", userInfo: somethingToPass, repeats: false)

func tester(timer: NSTimer)
{
    let theStringToPrint = timer.userInfo as String
    println(theStringToPrint)
}

Includi i due punti nel testo del selettore (tester :) e i tuoi parametri vanno in userInfo.

La tua funzione dovrebbe prendere NSTimer come parametro. Quindi estrarre userInfo per ottenere il parametro passato.

I selettori sono una rappresentazione interna di un nome di metodo in Objective-C. In Objective-C "@selector (methodName)" converte un metodo di codice sorgente in un tipo di dati di SEL. Dal momento che non è possibile utilizzare la sintassi @selector in Swift (il rickster è sul punto lì), è necessario specificare manualmente il nome del metodo come oggetto String o passando un oggetto String al tipo Selettore. Ecco un esempio:

var rightBarButton = UIBarButtonItem(
    title: "Logout", 
    style: UIBarButtonItemStyle.Plain, 
    target: self, 
    action:"logout"
)

o

var rightBarButton = UIBarButtonItem(
    title: "Logout", 
    style: UIBarButtonItemStyle.Plain, 
    target: self, 
    action:Selector("logout")
)

Swift 4.1
Con un esempio di gesto del tocco

let gestureRecognizer = UITapGestureRecognizer()
self.view.addGestureRecognizer(gestureRecognizer)
gestureRecognizer.addTarget(self, action: #selector(self.dismiss(completion:)))

// Use destination 'Class Name' directly, if you selector (function) is not in same class.
//gestureRecognizer.addTarget(self, action: #selector(DestinationClass.dismiss(completion:)))


@objc func dismiss(completion: (() -> Void)?) {
      self.dismiss(animated: true, completion: completion)
}

Consulta il documento di Apple per maggiori dettagli su: Selector Expression

// for swift 2.2
// version 1
buttton.addTarget(self, action: #selector(ViewController.tappedButton), forControlEvents: .TouchUpInside)
buttton.addTarget(self, action: #selector(ViewController.tappedButton2(_:)), forControlEvents: .TouchUpInside)

// version 2
buttton.addTarget(self, action: #selector(self.tappedButton), forControlEvents: .TouchUpInside)
buttton.addTarget(self, action: #selector(self.tappedButton2(_:)), forControlEvents: .TouchUpInside)

// version 3
buttton.addTarget(self, action: #selector(tappedButton), forControlEvents: .TouchUpInside)
buttton.addTarget(self, action: #selector(tappedButton2(_:)), forControlEvents: .TouchUpInside)

func tappedButton() {
  print("tapped")
}

func tappedButton2(sender: UIButton) {
  print("tapped 2")
}

// swift 3.x
button.addTarget(self, action: #selector(tappedButton(_:)), for: .touchUpInside)

func tappedButton(_ sender: UIButton) {
  // tapped
}

button.addTarget(self, action: #selector(tappedButton(_:_:)), for: .touchUpInside)

func tappedButton(_ sender: UIButton, _ event: UIEvent) {
  // tapped
}

Create Refresh control using Selector method.   
    var refreshCntrl : UIRefreshControl!
    refreshCntrl = UIRefreshControl()
    refreshCntrl.tintColor = UIColor.whiteColor()
    refreshCntrl.attributedTitle = NSAttributedString(string: "Please Wait...")
    refreshCntrl.addTarget(self, action:"refreshControlValueChanged", forControlEvents: UIControlEvents.ValueChanged)
    atableView.addSubview(refreshCntrl)

// Aggiorna metodo di controllo

func refreshControlValueChanged(){
    atableView.reloadData()
    refreshCntrl.endRefreshing()

}

Dal momento che Swift 3.0 è stato pubblicato, è persino un po 'più sottile dichiarare appropriata un'azione target

class MyCustomView : UIView {

    func addTapGestureRecognizer() {

        // the "_" is important
        let tapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(MyCustomView.handleTapGesture(_:)))
        tapGestureRecognizer.numberOfTapsRequired = 1
        addGestureRecognizer(tapGestureRecognizer)
    }

    // since Swift 3.0 this "_" in the method implementation is very important to 
    // let the selector understand the targetAction
    func handleTapGesture(_ tapGesture : UITapGestureRecognizer) {

        if tapGesture.state == .ended {
            print("TapGesture detected")
        }
    }
}

Quando si usa performSelector()

/addtarget()/NStimer.scheduledTimerWithInterval() metodi il metodo (corrispondente al selettore) deve essere contrassegnato come

@objc
For Swift 2.0:
    {  
        //...
        self.performSelector(“performMethod”, withObject: nil , afterDelay: 0.5)
        //...


    //...
    btnHome.addTarget(self, action: “buttonPressed:", forControlEvents: UIControlEvents.TouchUpInside)
    //...

    //...
     NSTimer.scheduledTimerWithTimeInterval(0.5, target: self, selector : “timerMethod”, userInfo: nil, repeats: false)
    //...

}

@objc private func performMethod() {
…
}
@objc private func buttonPressed(sender:UIButton){
….
}
@objc private func timerMethod () {
….
}

Per Swift 2.2, è necessario scrivere '#selector ()' invece del nome della stringa e del selettore in modo che le possibilità di errori di ortografia e crash dovute a questo non siano più presenti. Di seguito è riportato un esempio

self.performSelector(#selector(MyClass.performMethod), withObject: nil , afterDelay: 0.5)

crei il Selettore come sotto.
1.

UIBarButtonItem(
    title: "Some Title",
    style: UIBarButtonItemStyle.Done,
    target: self,
    action: "flatButtonPressed"
)

2.

flatButton.addTarget(self, action: "flatButtonPressed:", forControlEvents: UIControlEvents.TouchUpInside)

Si noti che la sintassi @selector è scomparsa e sostituita con una semplice stringa che nomina il metodo da chiamare. C'è un'area in cui possiamo essere tutti d'accordo sul fatto che la verbosità abbia ostacolato. Naturalmente, se dichiarassimo che esiste un metodo target chiamato flatButtonPressed: è meglio scriverne uno:

func flatButtonPressed(sender: AnyObject) {
  NSLog("flatButtonPressed")
}

imposta il timer:

    var timer = NSTimer.scheduledTimerWithTimeInterval(1.0, 
                    target: self, 
                    selector: Selector("flatButtonPressed"), 
                    userInfo: userInfo, 
                    repeats: true)
    let mainLoop = NSRunLoop.mainRunLoop()  //1
    mainLoop.addTimer(timer, forMode: NSDefaultRunLoopMode) //2 this two line is optinal

Per essere completo, ecco flatButtonPressed

func flatButtonPressed(timer: NSTimer) {
}

Ho trovato molte di queste risposte utili, ma non era chiaro come farlo con qualcosa che non era un pulsante. Stavo aggiungendo un riconoscitore di gesti a un UILabel in modo rapido e faticoso, quindi ecco quello che ho trovato ha funzionato per me dopo aver letto tutto sopra:

let tapRecognizer = UITapGestureRecognizer(
            target: self,
            action: "labelTapped:")

Dove il "Selettore" è stato dichiarato come:

func labelTapped(sender: UILabel) { }

Nota che è pubblico e che non sto usando la sintassi Selector () ma è possibile farlo anche.

let tapRecognizer = UITapGestureRecognizer(
            target: self,
            action: Selector("labelTapped:"))

L'utilizzo di #selector verificherà il codice al momento della compilazione per assicurarsi che il metodo che desideri chiamare esista effettivamente. Ancora meglio, se il metodo non esiste, otterrai un errore di compilazione: Xcode rifiuterà di costruire la tua app, bandendo così l'oblio di un'altra possibile fonte di bug.

override func viewDidLoad() {
        super.viewDidLoad()

        navigationItem.rightBarButtonItem =
            UIBarButtonItem(barButtonSystemItem: .Add, target: self,
                            action: #selector(addNewFireflyRefernce))
    }

    func addNewFireflyReference() {
        gratuitousReferences.append("Curse your sudden but inevitable betrayal!")
    }

Può essere utile annotare dove si imposta il controllo che innesca l'azione.

Ad esempio, ho scoperto che durante l'impostazione di UIBarButtonItem, dovevo creare il pulsante in viewDidLoad, altrimenti avrei ottenuto un'eccezione del selettore non riconosciuta.

override func viewDidLoad() {
    super.viewDidLoad() 

    // add button
    let addButton = UIBarButtonItem(image: UIImage(named: "746-plus-circle.png"), style: UIBarButtonItemStyle.Plain, target: self, action: Selector("addAction:"))
    self.navigationItem.rightBarButtonItem = addButton
}

func addAction(send: AnyObject?) {     
    NSLog("addAction")
}

selectorè una parola dal Objective-Cmondo e sei in grado di usarlo da Swiftper avere la possibilità di chiamare Objective-Cda Swift Ti permette di eseguire del codice in fase di esecuzione

Prima che Swift 2.2la sintassi sia:

Selector("foo:")

Poiché un nome di funzione viene passato Selectorcome Stringparametro ("pippo"), non è possibile controllare un nome in fase di compilazione . Di conseguenza è possibile ottenere un errore di runtime:

unrecognized selector sent to instance

Dopo Swift 2.2+la sintassi è:

#selector(foo(_:))

Il completamento automatico di Xcode ti aiuta a chiamare il metodo giusto

Cambia come una semplice denominazione di stringa nel metodo che richiede la sintassi del selettore

var timer1 : NSTimer? = nil
timer1= NSTimer(timeInterval: 0.1, target: self, selector: Selector("test"), userInfo: nil, repeats: true)

Successivamente, digita func test ().

Per Swift 3

// Codice di esempio per creare un timer

Timer.scheduledTimer(timeInterval: 1, target: self, selector: (#selector(updateTimer)), userInfo: nil, repeats: true)

WHERE
timeInterval:- Interval in which timer should fire like 1s, 10s, 100s etc. [Its value is in secs]
target:- function which pointed to class. So here I am pointing to current class.
selector:- function that will execute when timer fires.

func updateTimer(){
    //Implemetation 
} 

repeats:- true/false specifies that timer should call again n again.

Selettore in Swift 4:

button.addTarget(self, action: #selector(buttonTapped(sender:)), for: UIControlEvents.touchUpInside)

Per rapido 3

let timer = Timer.scheduledTimer(timeInterval: 0.01, target: self, selector: #selector(self.test), userInfo: nil, repeats: true)

Dichiarazione di funzione Nella stessa classe:

@objc func test()
{
    // my function
}