iOS
UITextField Délégué

UITextField - Limite le champ de texte à certains caractères

Si vous souhaitez effectuer une validation de saisie de votre champ de texte par l'utilisateur, utilisez l'extrait de code suivant:

// MARK: - UITextFieldDelegate

let allowedCharacters = CharacterSet(charactersIn:"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvxyz").inverted    

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    
    let components = string.components(separatedBy: allowedCharacters)
    let filtered = components.joined(separator: "")
    
    if string == filtered {
        
        return true

    } else {
        
        return false
    }
}

Objectif c

#define ACCEPTABLE_CHARACTERS @"0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string  
{
      NSCharacterSet *cs = [[NSCharacterSet characterSetWithCharactersInString:ACCEPTABLE_CHARACTERS] invertedSet];

      NSString *filtered = [[string componentsSeparatedByCharactersInSet:cs] componentsJoinedByString:@""];

      return [string isEqualToString:filtered];
}

De plus, vous pouvez également utiliser les jeux de caractères fournis par Apple pour effectuer la validation:

Jetez un oeil à https://developer.apple.com/reference/foundation/nscharacterset

let allowedCharacters = CharacterSet.alphanumerics.inverted
let allowedCharacters = CharacterSet.capitalizedLetters.inverted

Trouver le prochain tag et gérer le clavier

Le champ de texte appelle différentes méthodes de délégation (uniquement si des délégués sont définis) Une des méthodes déléguées appelée par textfield est * - (BOOL) textFieldShouldReturn: (UITextField ) textField

Cette méthode est appelée chaque fois que l'utilisateur appuie sur le bouton de retour. En utilisant cette méthode, nous pouvons implémenter tout comportement personnalisé.

Par exemple,

Dans l'exemple ci-dessous, le prochain répondeur sera trouvé sur la base du tag et gérera le clavier. Ici 20 est la constante, comme tag assigné à textfield sont comme ceci 50,70,90 etc.

Ici, pour trouver un nouvel objet textfield en tant que répondeur, il créera le champ de texte actuel comme nouveau répondeur et ouvrira le clavier en conséquence.

 - (BOOL)textFieldShouldReturn:(UITextField *)textField {

                NSInteger nextTag = textField.tag+20;
                // Try to find next responder
                UIResponder *nextResponder = [textField.superview viewWithTag:nextTag];
                if (nextResponder)
                {
                    // Found next responder, so set it.
                    [nextResponder becomeFirstResponder];
                }
                else
                {
                    // Not found, so remove keyboard.
                    [textField resignFirstResponder];
                }
                return YES;
            }

Actions lorsqu'un utilisateur a commencé / a fini d'interagir avec un champ de texte

Pour Swift 3.1:

Dans le premier exemple, on peut voir comment intercepter l'utilisateur interagissant avec un champ de texte lors de l'écriture. De même, certaines méthodes de UITextFieldDelegate sont appelées lorsqu'un utilisateur a démarré et a mis fin à son interaction avec un objet TextField.

Pour pouvoir accéder à ces méthodes, vous devez vous conformer au protocole UITextFieldDelegate et, pour chaque champ de texte à notifier, affectez la classe parente en tant que déléguée:

class SomeClass: UITextFieldDelegate {
    
    @IBOutlet var textField: UITextField!

    override func viewDidLoad() {
        super.viewDidLoad()
        textField.delegate = self
    }

}

Vous pourrez maintenant implémenter toutes les méthodes UITextFieldDelegate.

Pour être averti lorsqu'un utilisateur a commencé à modifier un champ de texte, vous pouvez implémenter la méthode textFieldDidBeginEditing (_ :) comme suit:

func textFieldDidBeginEditing(_ textField: UITextField) {
    // now you can perform some action 
    // if you have multiple textfields in a class, 
    // you can compare them here to handle each one separately
    if textField == emailTextField {
        // e.g. validate email 
    } 
    else if textField == passwordTextField {
        // e.g. validate password 
    } 
}

De même, être averti si un utilisateur a mis fin à une interaction avec un champ de texte, vous pouvez utiliser la méthode textFieldDidEndEditing (_ :) comme ceci:

func textFieldDidEndEditing(_ textField: UITextField) {
    // now you can perform some action 
    // if you have multiple textfields in a class, 
    // you can compare them here to handle each one separately
    if textField == emailTextField {
        // e.g. validate email 
    } 
    else if textField == passwordTextField {
        // e.g. validate password 
    } 
}

Si vous souhaitez contrôler si un objet TextField doit commencer / finir l'édition, les méthodes textFieldShouldBeginEditing (_ :) et textFieldShouldEndEditing (_ :) peuvent être utilisées en renvoyant true / false en fonction de la logique requise.