@selector () dans Swift?

J'essaie de créer un NSTimerin Swiftmais j'ai des problèmes.

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

test() est une fonction de la même classe.

Je reçois une erreur dans l'éditeur:

Impossible de trouver une surcharge pour 'init' qui accepte les arguments fournis

Lorsque je passe selector: test()à selector: nill'erreur, disparaît.

J'ai essayé:

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

Mais rien ne fonctionne et je ne trouve pas de solution dans les références.

Swift lui - même n'utilise pas de sélecteurs - plusieurs modèles de conception qui dans Objective-C utilisent des sélecteurs fonctionnent différemment dans Swift. (Par exemple, utilisez le chaînage facultatif sur les types de protocole ou is/ astests au lieu de respondsToSelector:, et utilisez des fermetures partout où vous le pouvez performSelector:pour une meilleure sécurité de type / mémoire.)

Mais il existe encore un certain nombre d'API importantes basées sur ObjC qui utilisent des sélecteurs, y compris des minuteries et le modèle cible / action. Swift fournit le Selectortype pour travailler avec ces derniers. (Swift l'utilise automatiquement à la place du SELtype d'ObjC .)

Dans Swift 2.2 (Xcode 7.3) et versions ultérieures (y compris Swift 3 / Xcode 8 et Swift 4 / Xcode 9):

Vous pouvez construire un à Selectorpartir d'un type de fonction Swift à l'aide de l' #selectorexpression.

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 grande chose à propos de cette approche? Une référence de fonction est vérifiée par le compilateur Swift, vous pouvez donc utiliser l' #selectorexpression uniquement avec des paires classe / méthode qui existent réellement et peuvent être utilisées comme sélecteurs (voir «Disponibilité du sélecteur» ci-dessous). Vous êtes également libre de faire votre référence de fonction uniquement aussi spécifique que vous le souhaitez, conformément aux règles Swift 2.2+ pour la dénomination de type de fonction .

(Il s'agit en fait d'une amélioration par rapport à la @selector()directive ObjC , car la -Wundeclared-selectorvérification du compilateur vérifie uniquement que le sélecteur nommé existe. La référence à la fonction Swift que vous passez pour #selectorvérifier l'existence, l'appartenance à une classe et la signature de type.)

Il y a quelques mises en garde supplémentaires pour les références de fonction que vous passez à l' #selectorexpression:

• Plusieurs fonctions avec le même nom de base peuvent être différenciées par leurs étiquettes de paramètres en utilisant la syntaxe susmentionnée pour les références de fonction (par exemple insertSubview(_:at:)vs insertSubview(_:aboveSubview:)). Mais si une fonction n'a pas de paramètres, la seule façon de lever l'ambiguïté est d'utiliser un astranstypage avec la signature de type de la fonction (par exemple foo as () -> ()vs foo(_:)).
• Il existe une syntaxe spéciale pour les paires getter / setter de propriété dans Swift 3.0+. Par exemple, étant donné un var foo: Int, vous pouvez utiliser #selector(getter: MyClass.foo)ou #selector(setter: MyClass.foo).

Notes générales:

Cas où #selectorcela ne fonctionne pas et dénomination: Parfois, vous n'avez pas de référence de fonction avec laquelle faire un sélecteur (par exemple, avec des méthodes enregistrées dynamiquement dans le runtime ObjC). Dans ce cas, vous pouvez construire un à Selectorpartir d'une chaîne: par exemple Selector("dynamicMethod:")- bien que vous perdiez la vérification de validité du compilateur. Lorsque vous faites cela, vous devez suivre les règles de dénomination ObjC, y compris les deux-points ( :) pour chaque paramètre.

Disponibilité du sélecteur: la méthode référencée par le sélecteur doit être exposée au runtime ObjC. Dans Swift 4, chaque méthode exposée à ObjC doit avoir sa déclaration précédée de l' @objcattribut. (Dans les versions précédentes, vous disposiez de cet attribut gratuitement dans certains cas, mais maintenant vous devez le déclarer explicitement.)

N'oubliez pas que les privatesymboles ne sont pas non plus exposés à l'exécution - votre méthode doit avoir au moins une internalvisibilité.

Chemins d'accès: ceux-ci sont liés mais pas tout à fait identiques aux sélecteurs. Il y a aussi une syntaxe spéciale pour ceux-ci dans Swift 3: par exemple chris.valueForKeyPath(#keyPath(Person.friends.firstName)). Voir SE-0062 pour plus de détails. Et encore plus de KeyPathchoses dans Swift 4 , alors assurez-vous d'utiliser la bonne API basée sur KeyPath au lieu de sélecteurs, le cas échéant.

Vous pouvez en savoir plus sur les sélecteurs sous Interagir avec les API Objective-C dans Utilisation de Swift avec Cocoa et Objective-C .

^{Remarque: Avant Swift 2.2, Selectorconforme à StringLiteralConvertible, vous pouvez donc trouver de l'ancien code où des chaînes nues sont passées aux API qui acceptent les sélecteurs. Vous aurez envie d'exécuter "Convertir en syntaxe Swift actuelle" dans Xcode pour obtenir ceux qui utilisent #selector.}

Voici un exemple rapide sur la façon d'utiliser la Selectorclasse sur 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   
}

Notez que si la méthode passée sous forme de chaîne ne fonctionne pas, elle échouera lors de l'exécution, pas lors de la compilation, et plantera votre application. Faites attention

De plus, si votre classe (Swift) ne descend pas d'une classe Objective-C, vous devez avoir deux points à la fin de la chaîne de nom de la méthode cible et vous devez utiliser la propriété @objc avec votre méthode cible, par exemple

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

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

sinon, vous obtiendrez une erreur «Sélecteur non reconnu» lors de l'exécution.

Mise à jour Swift 2.2+ et Swift 3

Utilisez la nouvelle #selectorexpression, ce qui élimine le besoin d'utiliser des littéraux de chaîne rendant l'utilisation moins sujette aux erreurs. Pour référence:

Selector("keyboardDidHide:")

devient

#selector(keyboardDidHide(_:))

Voir aussi: Proposition Swift Evolution

Remarque (Swift 4.0):

Si #selectorvous utilisez, vous devrez marquer la fonction comme@objc

Exemple:

@objc func something(_ sender: UIButton)

Swift 4.0

vous créez le sélecteur comme ci-dessous.

1. ajoutez l'événement à un bouton comme:

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

et la fonction sera comme ci-dessous:

@objc func clickedButton(sender: AnyObject) {

}

Pour les futurs lecteurs, j'ai constaté que j'avais rencontré un problème et que j'obtenais une unrecognised selector sent to instanceerreur causée par le marquage de la cible funccomme privée.

Le func DOIT être publiquement visible pour être appelé par un objet avec une référence à un sélecteur.

Juste au cas où quelqu'un d'autre aurait le même problème que j'ai eu avec NSTimer où aucune des autres réponses n'a résolu le problème, il est vraiment important de mentionner que, si vous utilisez une classe qui n'hérite pas de NSObject directement ou profondément dans la hiérarchie ( par exemple des fichiers swift créés manuellement), aucune des autres réponses ne fonctionnera même si est spécifié comme suit:

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

Sans rien changer d'autre que de simplement faire hériter la classe de NSObject, j'ai cessé d'obtenir l'erreur "sélecteur non reconnu" et j'ai fait fonctionner ma logique comme prévu.

Si vous souhaitez passer un paramètre à la fonction à partir du NSTimer, voici votre solution:

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

Incluez les deux-points dans le texte du sélecteur (testeur :) et vos paramètres vont dans userInfo.

Votre fonction doit prendre NSTimer comme paramètre. Il suffit ensuite d'extraire userInfo pour obtenir le paramètre transmis.

Les sélecteurs sont une représentation interne d'un nom de méthode dans Objective-C. Dans Objective-C, "@selector (methodName)" convertirait une méthode de code source en un type de données SEL. Étant donné que vous ne pouvez pas utiliser la syntaxe @selector dans Swift (rickster est là), vous devez spécifier manuellement le nom de la méthode en tant qu'objet String directement, ou en passant un objet String au type Selector. Voici un exemple:

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

ou

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

Swift 4.1
Avec un échantillon du geste du robinet

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

Voir le document d'Apple pour plus de détails sur: Expression du sélecteur

// 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)

// Actualiser la méthode de contrôle

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

}

Depuis la publication de Swift 3.0, il est même un peu plus subtil de déclarer une action cible appropriée

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

Lors de l'utilisation performSelector()

/addtarget()/NStimer.scheduledTimerWithInterval() méthodes votre méthode (correspondant au sélecteur) doit être marquée comme

@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 () {
….
}

Pour Swift 2.2, vous devez écrire '#selector ()' au lieu de la chaîne et du nom du sélecteur afin que les possibilités d'erreur d'orthographe et de plantage à cause de cela ne soient plus là. Voici un exemple

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

vous créez le sélecteur comme ci-dessous.
1.

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

2.

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

Notez que la syntaxe @selector a disparu et a été remplacée par une simple chaîne nommant la méthode à appeler. Il y a un domaine où nous pouvons tous convenir que la verbosité s'est mise en travers. Bien sûr, si nous déclarons qu'il existe une méthode cible appelée flatButtonPressed: il vaut mieux en écrire une:

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

régler la minuterie:

    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

Pour être complet, voici le flatButtonPressed

func flatButtonPressed(timer: NSTimer) {
}

J'ai trouvé bon nombre de ces réponses utiles, mais il n'était pas clair comment procéder avec quelque chose qui n'était pas un bouton. J'étais en train d'ajouter un reconnaisseur de gestes à un UILabel rapidement et j'ai eu du mal alors voici ce que j'ai trouvé qui fonctionnait pour moi après avoir lu tout ce qui précède:

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

Où le "sélecteur" a été déclaré:

func labelTapped(sender: UILabel) { }

Notez qu'il est public et que je n'utilise pas la syntaxe Selector () mais il est également possible de le faire.

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

L'utilisation de #selector vérifiera votre code au moment de la compilation pour vous assurer que la méthode que vous souhaitez appeler existe réellement. Encore mieux, si la méthode n'existe pas, vous obtiendrez une erreur de compilation: Xcode refusera de construire votre application, bannissant ainsi de l'oubli une autre source possible de bugs.

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

Il peut être utile de noter où vous configurez le contrôle qui déclenche l'action.

Par exemple, j'ai constaté que lors de la configuration d'un UIBarButtonItem, je devais créer le bouton dans viewDidLoad, sinon j'obtiendrais une exception de sélecteur non reconnue.

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

selectorest un mot du Objective-Cmonde et vous pouvez l'utiliser Swiftpour avoir la possibilité d'appeler Objective-Cdepuis Swift Il vous permet d'exécuter du code à l'exécution

Avant Swift 2.2la syntaxe est:

Selector("foo:")

Étant donné que le nom de la fonction est passée en Selectortant que Stringparamètre ( « foo ») , il est impossible de vérifier un nom dans la compilation . En conséquence, vous pouvez obtenir une erreur d'exécution:

unrecognized selector sent to instance

Après Swift 2.2+la syntaxe:

#selector(foo(_:))

La saisie semi-automatique de Xcode vous aide à appeler une bonne méthode

Modifier comme une simple dénomination de chaîne dans la méthode appelant la syntaxe du sélecteur

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

Après cela, tapez func test ().

Pour Swift 3

// Exemple de code pour créer une minuterie

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.

Sélecteur dans Swift 4:

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

Pour swift 3

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

Déclaration de fonction Dans la même classe:

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