Swift - déterminer quel bouton a été pressé avec interrupteur

J'ai 4 boutons d'appel d'une fonction. Selon sur quel bouton a été pressé j'ai besoin de cacher le bouton à l'intérieur de la fonction qui a appelé après avoir appuyé sur.Je ne sais pas quel bouton a été pressé donc j'ai essayé d'attribuer des étiquettes pour chacun des 4 boutons pour identifier par la balise et de l'utilisation de l'interrupteur

J'ai essayé ce

            switch sender.tag {
            case 1:
                self.button1.hidden = true
            case 2:
                self.button2.hidden = true
            case 3:
                self.button3.hidden = true
            case 4:
                self.button4.hidden = true

            }

mais cela ne fonctionne pas de compilateur dit à propos de l'utilisation de suspens identificateur '"expéditeur"

Comment faire cela correctement ?

EDIT:

Ensemble de la fonction

  if self.allowMistakeVar {

        let mistakeAlert = UIAlertController(title: "Here is title!", message: "message of alert", preferredStyle: .Alert)
        let okay = UIAlertAction(title: "OK", style: .Cancel) { UIAlertAction in

            self.allowMistakeVar = false
            self.allowMistakeButton.enabled = false


            switch sender.tag {
            case answer1Text:
                self.answer1Text.hidden = true
            case answer2Text:
                self.answer2Text.hidden = true
            case answer3Text:
                self.answer3Text.hidden = true
            case answer4Text:
                self.answer4Text.hidden = true

            }

        }

        mistakeAlert.addAction(okay)
        self.presentViewController(mistakeAlert, animated: true, completion: nil )

    } else {

une autre affaire..
}

Comment faire pour appeler la fonction depuis le 4 boutons ?
s'il vous plaît montrer votre fonction entière où vous avez mis ce code.
Kukadiya updatet post
après que le bouton est pressé-je vérifier si le titre est égal à la variable A. si non, j'ai appeler la fonction à l'intérieur de laquelle j'ai vérifier si une autre variable B est vraie ou fausse et si c'est vrai j'ai besoin de cacher le bouton a été pressé
Pourquoi vous voulez toujours utiliser les balises pour déterminer la UIButton ? Si la fonction appelée est un paramètre sender, que vous connaissez le UIButton qui a appelé la fonction par le biais de ce paramètre

OriginalL'auteur Alexey K | 2015-08-13

Essayer cela,

1) Affecter une balise pour chaque bouton

Button1.tag=1
Button2.tag=2
Button3.tag=3
Button4.tag=4

2) Puis vérifiez votre commune bouton de action

func buttonClicked(sender: UIButton)
{
   switch sender.tag {
   case 1: self.sender.hidden = true //button1
           break;
   case 2: self.sender.hidden = true //button2
           break;
   case 3: self.sender.hidden = true //button3
           break;
   case 4: self.sender.hidden = true //button4
           break;
   default: ()
           break;
   }

}

OriginalL'auteur Manikandan D

10

Pourquoi vous voulez toujours utiliser les balises pour déterminer la UIButton ? Si la fonction appelée est un paramètre sender alors vous savez que la UIButton qui a appelé la fonction par le biais de ce paramètre.
```
func buttonClicked(sender: UIButton)
{
   switch sender {
   case button1: //Do something
   case button2: //Do some other stuff
   ...
   default: ()
   }

}
```
Je ne suis pas sûr que cela pourrait résoudre le problème parce que le message d'erreur qu'il a obtenu. Mais grâce. J'ai appris quelque chose.

OriginalL'auteur JulianM
4

Mettre votre code comme ci-dessous comme je l'ai montré:
```
func btnSomeButtonClicked(sender: UIButton)
{
let tag = sender.tag;
       //put your same code here and either use tag variable as i shown or put as you did.
}
```
--> en raison de cela, vous obtenez de l'expéditeur facilement.

-->vérifiez Également que vous n'avez pas oublié de donner des balises pour le UIButtons.

OriginalL'auteur Jecky

Je sais que cela a été répondu, mais si vous définissez ce jusqu'au bureau de l'IB, alors je vous recommande de vérifier si le bouton a été pressé en utilisant le @IBOutlet variables comme des cas.

class SomeView: UIView {
    @IBOutlet weak var buttonA: UIButton!
    @IBOutlet weak var buttonB: UIButton!
    @IBOutlet weak var buttonC: UIButton!

    @IBAction func didHitButton(_ sender: UIButton) {
        switch sender {
        case buttonA:
            doThis()
        }
        case buttonB:
            doThat()
        }
        case buttonC:
            doThisAgain()
        }
        default:
            doNothing()
        }
    }
    ...
}

Maintenant, vous raccorder les boutons de votre PLUME à chaque @IBOutlet, et tous les boutons à la une @IBAction didHitButton.

C'est assez simple, et vous n'avez pas à vous soucier des balises ou des changements de noms.

OriginalL'auteur GJ Nilsen

0

Plutôt puis à l'aide d'une instruction switch, vous pouvez simplement utiliser l'expéditeur directement.

Notez que vous devez spécifier l'expéditeur est un UIButton (donc cela ne fonctionne que si la fonction n'est appelée à partir d'un bouton).
```
@IBAction func submitButton(sender: UIButton) {

    /* extra code here */

    sender.enabled = false

}
```
Cela réduit le code et vous permet également d'ajouter des boutons supplémentaires sans modification de code.

OriginalL'auteur Matt G

Vous devez vous connecter pour publier un commentaire.