Comment naviguer dans les champs de texte (boutons Suivant / Terminé)

Comment puis-je parcourir tous mes champs de texte avec le bouton "Suivant" du clavier de l'iPhone?

Le dernier champ de texte devrait fermer le clavier.

J'ai configuré l'IB les boutons (Next / Done) mais maintenant je suis bloqué.

J'ai implémenté l'action textFieldShouldReturn mais maintenant les boutons Suivant et Terminé ferment le clavier.

Dans Cocoa pour Mac OS X, vous avez la chaîne de répondeurs suivante, où vous pouvez demander au champ de texte quel contrôle doit avoir le focus ensuite. C'est ce qui fait que la tabulation entre les champs de texte fonctionne. Mais comme les appareils iOS n'ont pas de clavier, seulement tactile, ce concept n'a pas survécu à la transition vers Cocoa Touch.

Cela peut être fait de toute façon facilement, avec deux hypothèses:

1. Tous les "tabulations" UITextFieldsont sur la même vue parent.
2. Leur "ordre de tabulation" est défini par la propriété tag.

En supposant cela, vous pouvez remplacer textFieldShouldReturn: comme ceci:

-(BOOL)textFieldShouldReturn:(UITextField*)textField
{
  NSInteger nextTag = textField.tag + 1;
  // 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 NO; // We do not want UITextField to insert line-breaks.
}

Ajoutez un peu plus de code et les hypothèses peuvent également être ignorées.

Swift 4.0

 func textFieldShouldReturn(_ textField: UITextField) -> Bool {
    let nextTag = textField.tag + 1
    // Try to find next responder
    let nextResponder = textField.superview?.viewWithTag(nextTag) as UIResponder!

    if nextResponder != nil {
        // Found next responder, so set it
        nextResponder?.becomeFirstResponder()
    } else {
        // Not found, so remove keyboard
        textField.resignFirstResponder()
    }

    return false
}

Si la vue d'ensemble du champ de texte sera un UITableViewCell, le prochain répondeur sera

let nextResponder = textField.superview?.superview?.superview?.viewWithTag(nextTag) as UIResponder!

Il existe une solution beaucoup plus élégante qui m'a époustouflée la première fois que je l'ai vue. Avantages:

• Plus proche de l'implémentation de champ de texte OSX où un champ de texte sait où le focus doit aller ensuite
• Ne repose pas sur la définition ou l'utilisation de balises - qui sont fragiles à l'OMI pour ce cas d'utilisation
• Peut être étendu pour fonctionner avec les deux commandes UITextFieldet UITextView- ou avec n'importe quel contrôle d'interface utilisateur d'entrée de clavier
• N'encombre pas votre contrôleur de vue avec le code délégué UITextField standard
• S'intègre parfaitement à IB et peut être configuré via l'option glisser-déposer familière pour connecter les prises.

Créez une sous-classe UITextField qui possède une IBOutletpropriété appelée nextField. Voici l'en-tête:

@interface SOTextField : UITextField

@property (weak, nonatomic) IBOutlet UITextField *nextField; 

@end

Et voici l'implémentation:

@implementation SOTextField

@end

Dans votre contrôleur de vue, vous allez créer la -textFieldShouldReturn:méthode déléguée:

- (BOOL)textFieldShouldReturn:(UITextField *)textField {
    if ([textField isKindOfClass:[SOTextField class]]) {
        UITextField *nextField = [(SOTextField *)textField nextField];

        if (nextField) {
            dispatch_async(dispatch_get_current_queue(), ^{
                [nextField becomeFirstResponder];
            });
        }
        else {
            [textField resignFirstResponder];
        }
    }

    return YES;
}

Dans IB, modifiez vos UITextFields pour utiliser la SOTextFieldclasse. Ensuite, également dans IB, définissez le délégué pour chacun des 'SOTextFields'to' File's Owner '(qui est juste là où vous mettez le code pour la méthode déléguée - textFieldShouldReturn). La beauté de cette conception est que vous pouvez maintenant simplement cliquer avec le bouton droit sur n'importe quel champ textField et affecter la sortie nextField au prochain SOTextFieldobjet dont vous voulez être le prochain intervenant.

De plus, vous pouvez faire des choses sympas comme boucler les textFields pour qu'après que le dernier ait perdu le focus, le premier recevra à nouveau le focus.

Cela peut facilement être étendu pour attribuer automatiquement returnKeyTypele SOTextFieldà un UIReturnKeyNexts'il y a un nextField affecté - une chose de moins à configurer manuellement.

En voici un sans délégation:

tf1.addTarget(tf2, action: #selector(becomeFirstResponder), for: .editingDidEndOnExit)
tf2.addTarget(tf3, action: #selector(becomeFirstResponder), for: .editingDidEndOnExit)

ObjC:

[tf1 addTarget:tf2 action:@selector(becomeFirstResponder) forControlEvents:UIControlEventEditingDidEndOnExit];
[tf2 addTarget:tf3 action:@selector(becomeFirstResponder) forControlEvents:UIControlEventEditingDidEndOnExit];

Fonctionne en utilisant l'action (principalement inconnue) UIControlEventEditingDidEndOnExit UITextField.

Vous pouvez également facilement le connecter dans le storyboard, donc aucune délégation ou code n'est requis.

Edit: en fait, je ne peux pas comprendre comment connecter cela dans le storyboard. becomeFirstResponderne semble pas être une action offerte pour cet événement de contrôle, ce qui est dommage. Néanmoins, vous pouvez connecter tous vos champs de texte à une seule action dans votre ViewController qui détermine ensuite le champ de texte à becomeFirstResponderbasé sur l'expéditeur (bien qu'il ne soit pas aussi élégant que la solution de programmation ci-dessus, IMO le fait avec le code ci-dessus viewDidLoad).

Voici ma solution pour ce problème.

Pour résoudre ce problème (et parce que je déteste me fier aux balises pour faire des choses), j'ai décidé d'ajouter une propriété personnalisée à l'objet UITextField. En d'autres termes, j'ai créé une catégorie sur UITextField comme ceci:

UITextField + Extended.h

@interface UITextField (Extended)

@property(retain, nonatomic)UITextField* nextTextField;

@end

UITextField + Extended.m

#import "UITextField+Extended.h"
#import <objc/runtime.h>

static char defaultHashKey;

@implementation UITextField (Extended)

- (UITextField*) nextTextField { 
    return objc_getAssociatedObject(self, &defaultHashKey); 
}

- (void) setNextTextField:(UITextField *)nextTextField{
    objc_setAssociatedObject(self, &defaultHashKey, nextTextField, OBJC_ASSOCIATION_RETAIN_NONATOMIC); 
}

@end

Maintenant, voici comment je l'utilise:

UITextField *textField1 = ...init your textfield
UITextField *textField2 = ...init your textfield
UITextField *textField3 = ...init your textfield

textField1.nextTextField = textField2;
textField2.nextTextField = textField3;
textField3.nextTextField = nil;

Et implémentez la méthode textFieldShouldReturn:

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

    UITextField *next = theTextField.nextTextField;
    if (next) {
        [next becomeFirstResponder];
    } else {
        [theTextField resignFirstResponder];
    }

    return NO; 
}

J'ai maintenant une sorte de liste chaînée d'UITextField, chacun sachant qui est le prochain dans la ligne.

J'espère que cela vous aidera.

Une extension rapide qui applique la réponse de mxcl pour rendre cela particulièrement facile (adapté à swift 2.3 par Traveler):

extension UITextField {
    class func connectFields(fields:[UITextField]) -> Void {
        guard let last = fields.last else {
            return
        }
        for i in 0 ..< fields.count - 1 {
            fields[i].returnKeyType = .Next
            fields[i].addTarget(fields[i+1], action: "becomeFirstResponder", forControlEvents: .EditingDidEndOnExit)
        }
        last.returnKeyType = .Done
        last.addTarget(last, action: #selector(UIResponder.resignFirstResponder), forControlEvents: .EditingDidEndOnExit)
    }
}

C'est simple à utiliser:

UITextField.connectFields([field1, field2, field3])

L'extension définira le bouton de retour sur "Suivant" pour tous sauf le dernier champ et sur "Terminé" pour le dernier champ, et changera le focus / fermera le clavier lorsque ceux-ci seront tapés.

Rapide <2,3

extension UITextField {
    class func connectFields(fields:[UITextField]) -> Void {
        guard let last = fields.last else {
            return
        }
        for var i = 0; i < fields.count - 1; i += 1 {
            fields[i].returnKeyType = .Next
            fields[i].addTarget(fields[i+1], action: "becomeFirstResponder", forControlEvents: .EditingDidEndOnExit)
        }
        last.returnKeyType = .Done
        last.addTarget(last, action: "resignFirstResponder", forControlEvents: .EditingDidEndOnExit)
    }
}

SWIFT 3: utilisez comme ceci -

UITextField.connectFields(fields: [field1, field2])

Extension:
    extension UITextField {
        class func connectFields(fields:[UITextField]) -> Void {
            guard let last = fields.last else {
                return
            }
            for i in 0 ..< fields.count - 1 {
                fields[i].returnKeyType = .next
                fields[i].addTarget(fields[i+1], action: #selector(UIResponder.becomeFirstResponder), for: .editingDidEndOnExit)
            }
            last.returnKeyType = .go
            last.addTarget(last, action: #selector(UIResponder.resignFirstResponder), for: .editingDidEndOnExit)
        }
    }

Une manière plus cohérente et robuste consiste à utiliser NextResponderTextField. Vous pouvez le configurer totalement à partir du générateur d'interface sans avoir besoin de définir le délégué ou d'utiliser view.tag.

Tout ce que vous devez faire c'est

1. Définissez le type de classe de votre UITextFieldêtreNextResponderTextField
2. Ensuite, définissez la sortie de la nextResponderFieldpour pointer vers le répondeur suivant, il peut être n'importe quoi UITextFieldou n'importe quelle UIRespondersous-classe. Il peut également s'agir d'un TouchUpInsidebouton UIB et la bibliothèque est suffisamment intelligente pour déclencher l' événement du bouton uniquement s'il est activé.

Voici la bibliothèque en action:

J'aime les solutions OO déjà proposées par Anth0 et Answerbot. Cependant, je travaillais sur un POC rapide et petit, donc je ne voulais pas encombrer les choses avec des sous-classes et des catégories.

Une autre solution simple consiste à créer un NSArray de champs et à rechercher le champ suivant lorsque vous appuyez sur suivant. Pas une solution OO, mais rapide, simple et facile à mettre en œuvre. De plus, vous pouvez voir et modifier la commande en un coup d'œil.

Voici mon code (construit sur d'autres réponses dans ce fil):

@property (nonatomic) NSArray *fieldArray;

- (void)viewDidLoad {
    [super viewDidLoad];

    fieldArray = [NSArray arrayWithObjects: firstField, secondField, thirdField, nil];
}

- (BOOL) textFieldShouldReturn:(UITextField *) textField {
    BOOL didResign = [textField resignFirstResponder];
    if (!didResign) return NO;

    NSUInteger index = [self.fieldArray indexOfObject:textField];
    if (index == NSNotFound || index + 1 == fieldArray.count) return NO;

    id nextField = [fieldArray objectAtIndex:index + 1];
    activeField = nextField;
    [nextField becomeFirstResponder];

    return NO;
}

• Je retourne toujours NON car je ne veux pas qu'un saut de ligne soit inséré. Je pensais juste le souligner car lorsque je retournais OUI, il quitterait automatiquement les champs suivants ou insèrerait un saut de ligne dans mon TextView. Cela m'a pris un peu de temps pour comprendre cela.
• activeField garde une trace du champ actif au cas où le défilement est nécessaire pour dégager le champ du clavier. Si vous avez un code similaire, assurez-vous d'attribuer le champ actif avant de changer le premier répondeur. Le changement de premier répondeur est immédiat et déclenche immédiatement l'événement KeyboardWasShown.

Voici une implémentation de tabulation à l'aide d'une catégorie sur UIControl. Cette solution présente tous les avantages des méthodes de Michael et Anth0, mais fonctionne pour tous les UIControls, pas seulement pour UITextFields. Il fonctionne également de manière transparente avec Interface Builder et les storyboards.

Source et exemple d'application: référentiel GitHub pour UIControlsWithTabbing

Usage:

- (BOOL)textFieldShouldReturn:(UITextField *)textField
{
    [textField transferFirstResponderToNextControl];
    return NO;
}

Entête:

//
// UIControl+NextControl.h
// UIControlsWithTabbing
//

#import <UIKit/UIKit.h>

@interface UIControl (NextControl)

@property (nonatomic, weak) IBOutlet UIControl *nextControl;

- (BOOL)transferFirstResponderToNextControl;

@end

La mise en oeuvre:

#import "UIControl+NextControl.h"
#import <objc/runtime.h>

static char defaultHashKey;

@implementation UIControl (NextControl)

- (UIControl *)nextControl
{
    return objc_getAssociatedObject(self, &defaultHashKey);
}

- (void)setNextControl:(UIControl *)nextControl
{
    objc_setAssociatedObject(self, &defaultHashKey, nextControl, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (BOOL)transferFirstResponderToNextControl
{
    if (self.nextControl)
    {
        [self.nextControl becomeFirstResponder];

        return YES;
    }

    [self resignFirstResponder];

    return NO;
}

@end

J'ai essayé de nombreux codes et enfin, cela a fonctionné pour moi dans Swift 3.0 Latest [mars 2017]

La ViewControllerclasse doit être héritée de UITextFieldDelegatepour que ce code fonctionne.

class ViewController: UIViewController,UITextFieldDelegate  

Ajoutez le champ Texte avec le numéro de balise approprié et ce numéro de balise est utilisé pour prendre le contrôle du champ de texte approprié en fonction du numéro de balise incrémentiel qui lui est attribué.

override func viewDidLoad() {
    userNameTextField.delegate = self
    userNameTextField.tag = 0
    userNameTextField.returnKeyType = UIReturnKeyType.next
    passwordTextField.delegate = self
    passwordTextField.tag = 1
    passwordTextField.returnKeyType = UIReturnKeyType.go
}

Dans le code ci-dessus, returnKeyType = UIReturnKeyType.nextoù fera la touche de retour du clavier à afficher, car Nextvous avez également d'autres options, Join/Goetc., en fonction de votre application, modifiez les valeurs.

Il textFieldShouldReturns'agit d'une méthode contrôlée par UITextFieldDelegate et nous avons ici la sélection de champ suivante basée sur l'incrémentation de la valeur de la balise

func textFieldShouldReturn(_ textField: UITextField) -> Bool {
    if let nextField = textField.superview?.viewWithTag(textField.tag + 1) as? UITextField {
        nextField.becomeFirstResponder()
    } else {
        textField.resignFirstResponder()
        return true;
    }
    return false
 }

Après avoir quitté un champ de texte, vous appelez [otherTextField devientFirstResponder] et le champ suivant obtient le focus.

Cela peut en fait être un problème délicat à résoudre car, souvent, vous souhaiterez également faire défiler l'écran ou ajuster la position du champ de texte afin qu'il soit facile à voir lors de la modification. Assurez-vous simplement de faire beaucoup de tests en entrant et en sortant des champs de texte de différentes manières et en partant tôt (donnez toujours à l'utilisateur la possibilité de fermer le clavier au lieu d'aller au champ suivant, généralement avec "Terminé" dans la barre de navigation)

 -(BOOL)textFieldShouldReturn:(UITextField *)textField
{
   [[self.view viewWithTag:textField.tag+1] becomeFirstResponder];
   return YES;
}

Une méthode très simple pour fermer le clavier lorsque vous appuyez sur le bouton «Terminé» est:

Créer une nouvelle IBAction dans l'en-tête

- (IBAction)textFieldDoneEditing:(id)sender;

Dans le fichier d'implémentation (fichier .m), ajoutez la méthode suivante:

- (IBAction)textFieldDoneEditing:(id)sender 
{ 
  [sender resignFirstResponder];
}

Ensuite, lorsque vous venez de lier l'IBAction au champ de texte - liez à l'événement 'Did End On Exit'.

Définissez d'abord la touche de retour du clavier dans xib, sinon vous pouvez écrire du code viewdidload:

passWord.returnKeyType = UIReturnKeyNext;

-(BOOL)textFieldShouldReturn:(UITextField *)textField
{
    if(textField == eMail) {
        [textField resignFirstResponder];
        [userName becomeFirstResponder];
    }
    if (textField==userName) {
        [textField resignFirstResponder];
        [passWord becomeFirstResponder];
    }
    if (textField==passWord) {
        [textField resignFirstResponder];
        [country becomeFirstResponder];
    }
    if (textField==country) {
        [textField resignFirstResponder];
    }
    return YES;
}

Je suis surpris du nombre de réponses qui ne parviennent pas à comprendre un concept simple: la navigation dans les contrôles de votre application n'est pas quelque chose que les vues elles-mêmes devraient faire. C'est le travail du contrôleur de décider quel contrôle faire le prochain premier répondant.

De plus, la plupart des réponses ne s'appliquent qu'à la navigation vers l'avant, mais les utilisateurs peuvent également vouloir revenir en arrière.

Voici donc ce que j'ai trouvé. Votre formulaire doit être géré par un contrôleur de vue, et les contrôleurs de vue font partie de la chaîne de répondeurs. Vous êtes donc parfaitement libre d'implémenter les méthodes suivantes:

#pragma mark - Key Commands

- (NSArray *)keyCommands
{
    static NSArray *commands;

    static dispatch_once_t once;
    dispatch_once(&once, ^{
        UIKeyCommand *const forward = [UIKeyCommand keyCommandWithInput:@"\t" modifierFlags:0 action:@selector(tabForward:)];
        UIKeyCommand *const backward = [UIKeyCommand keyCommandWithInput:@"\t" modifierFlags:UIKeyModifierShift action:@selector(tabBackward:)];

        commands = @[forward, backward];
    });

    return commands;
}

- (void)tabForward:(UIKeyCommand *)command
{
    NSArray *const controls = self.controls;
    UIResponder *firstResponder = nil;

    for (UIResponder *const responder in controls) {
        if (firstResponder != nil && responder.canBecomeFirstResponder) {
            [responder becomeFirstResponder]; return;
        }
        else if (responder.isFirstResponder) {
            firstResponder = responder;
        }
    }

    [controls.firstObject becomeFirstResponder];
}

- (void)tabBackward:(UIKeyCommand *)command
{
    NSArray *const controls = self.controls;
    UIResponder *firstResponder = nil;

    for (UIResponder *const responder in controls.reverseObjectEnumerator) {
        if (firstResponder != nil && responder.canBecomeFirstResponder) {
            [responder becomeFirstResponder]; return;
        }
        else if (responder.isFirstResponder) {
            firstResponder = responder;
        }
    }

    [controls.lastObject becomeFirstResponder];
}

Une logique supplémentaire pour faire défiler les répondeurs hors écran visibles à l'avance peut s'appliquer.

Un autre avantage de cette approche est que vous n'avez pas besoin de sous-classer toutes sortes de contrôles que vous souhaitez afficher (comme les UITextFields), mais que vous pouvez gérer la logique au niveau du contrôleur, où, soyons honnêtes, est le bon endroit pour le faire .

J'ai ajouté à la réponse de PeyloW au cas où vous cherchez à implémenter une fonctionnalité de bouton précédent / suivant:

- (IBAction)moveThroughTextFields:(UIBarButtonItem *)sender 
{
    NSInteger nextTag;
    UITextView *currentTextField = [self.view findFirstResponderAndReturn];

    if (currentTextField != nil) {
        // I assigned tags to the buttons.  0 represent prev & 1 represents next
        if (sender.tag == 0) {
            nextTag = currentTextField.tag - 1;

        } else if (sender.tag == 1) {
            nextTag = currentTextField.tag + 1;
        }
    }
    // Try to find next responder
    UIResponder* nextResponder = [self.view viewWithTag:nextTag];
    if (nextResponder) {
        // Found next responder, so set it.
        // I added the resign here in case there's different keyboards in place.
        [currentTextField resignFirstResponder];
        [nextResponder becomeFirstResponder];
    } else {
        // Not found, so remove keyboard.
        [currentTextField resignFirstResponder];

    }
}

Où vous sous-classez l'UIV comme ceci:

@implementation UIView (FindAndReturnFirstResponder)
- (UITextView *)findFirstResponderAndReturn
{
    for (UITextView *subView in self.subviews) {
        if (subView.isFirstResponder){
            return subView;
        }
    }
    return nil;
}
@end

Salut à tous s'il vous plaît voir celui-ci

- (void)nextPrevious:(id)sender
{

  UIView *responder = [self.view findFirstResponder];   

  if (nil == responder || ![responder isKindOfClass:[GroupTextField class]]) {
    return;
  }

  switch([(UISegmentedControl *)sender selectedSegmentIndex]) {
    case 0:
      // previous
      if (nil != ((GroupTextField *)responder).previousControl) {
        [((GroupTextField *)responder).previousControl becomeFirstResponder];
        DebugLog(@"currentControl: %i previousControl: %i",((GroupTextField *)responder).tag,((GroupTextField *)responder).previousControl.tag);
      }
      break;
    case 1:
      // next
      if (nil != ((GroupTextField *)responder).nextControl) {
        [((GroupTextField *)responder).nextControl becomeFirstResponder];
        DebugLog(@"currentControl: %i nextControl: %i",((GroupTextField *)responder).tag,((GroupTextField *)responder).nextControl.tag);
      }     
      break;    
  }
}

J'ai essayé de résoudre ce problème en utilisant une approche plus sophistiquée basée sur l'attribution de chaque cellule (ou UITextField) dans une UITableViewvaleur de balise unique qui peut être récupérée plus tard: activate-next-uitextfield-in-uitableview-ios

J'espère que ça aide!

Je viens de créer un nouveau pod lorsque j'ai affaire à ce truc GNTextFieldsCollectionManager . Il gère automatiquement le prochain / dernier problème textField et est très facile à utiliser:

[[GNTextFieldsCollectionManager alloc] initWithView:self.view];

Récupère tous les champs de texte triés en apparaissant dans la hiérarchie des vues (ou par balises), ou vous pouvez spécifier votre propre tableau de textFields.

Solution dans Swift 3.1, après avoir connecté vos champs de texte IBOutlets définissez votre délégué de champs de texte dans viewDidLoad, puis parcourez votre action dans textFieldShouldReturn

class YourViewController: UIViewController,UITextFieldDelegate {

        @IBOutlet weak var passwordTextField: UITextField!
        @IBOutlet weak var phoneTextField: UITextField!

        override func viewDidLoad() {
            super.viewDidLoad()
            self.passwordTextField.delegate = self
            self.phoneTextField.delegate = self
            // Set your return type
            self.phoneTextField.returnKeyType = .next
            self.passwordTextField.returnKeyType = .done
        }

        func textFieldShouldReturn(_ textField: UITextField) -> Bool{
            if textField == self.phoneTextField {
                self.passwordTextField.becomeFirstResponder()
            }else if textField == self.passwordTextField{
                // Call login api
                self.login()
            }
            return true
        }

    }

Si quelqu'un veut comme ça. Je pense que c'est le plus proche des exigences demandées en question

Voici comment j'ai implémenté celui-ci

Ajoutez une vue accessoire pour chaque champ de texte pour lequel vous souhaitez effectuer la configuration, en utilisant

func setAccessoryViewFor(textField : UITextField)    {
    let toolBar = UIToolbar()
    toolBar.barStyle = .default
    toolBar.isTranslucent = true
    toolBar.sizeToFit()

    // Adds the buttons

    // Add previousButton
    let prevButton = UIBarButtonItem(title: "<", style: .plain, target: self, action: #selector(previousPressed(sender:)))
    prevButton.tag = textField.tag
    if getPreviousResponderFor(tag: textField.tag) == nil {
        prevButton.isEnabled = false
    }

    // Add nextButton
    let nextButton = UIBarButtonItem(title: ">", style: .plain, target: self, action: #selector(nextPressed(sender:)))
    nextButton.tag = textField.tag
    if getNextResponderFor(tag: textField.tag) == nil {
        nextButton.title = "Done"
    }

    let spaceButton = UIBarButtonItem(barButtonSystemItem: .flexibleSpace, target: nil, action: nil)
    toolBar.setItems([prevButton,spaceButton,nextButton], animated: false)
    toolBar.isUserInteractionEnabled = true
    textField.inputAccessoryView = toolBar
}

Utilisez les fonctions suivantes pour gérer les taps

func nextPressed(sender : UIBarButtonItem) {
    if let nextResponder = getNextResponderFor(tag: sender.tag) {
        nextResponder.becomeFirstResponder()
    } else {
        self.view.endEditing(true)
    }

}

func previousPressed(sender : UIBarButtonItem) {
    if let previousResponder = getPreviousResponderFor(tag : sender.tag)  {
        previousResponder.becomeFirstResponder()
    }
}

func getNextResponderFor(tag : Int) -> UITextField? {
    return self.view.viewWithTag(tag + 1) as? UITextField
}

func getPreviousResponderFor(tag : Int) -> UITextField? {
    return self.view.viewWithTag(tag - 1) as? UITextField
}

Vous devrez donner aux balises textFields dans l'ordre dans lequel vous souhaitez que le bouton suivant / précédent réponde.

Je préfère plutôt:

@interface MyViewController : UIViewController
@property (nonatomic, retain) IBOutletCollection(UIView) NSArray *inputFields;
@end

Dans le fichier NIB, je raccorde les textFields dans l'ordre souhaité à ce tableau inputFields. Après cela, je fais un test simple pour l'index de l'UITextField qui signale que l'utilisateur a tapé sur retour:

// for UITextField
-(BOOL)textFieldShouldReturn:(UITextField*)textField {
    NSUInteger index = [_inputFields indexOfObject:textField];
    index++;
    if (index < _inputFields.count) {
        UIView *v = [_inputFields objectAtIndex:index];
        [v becomeFirstResponder];
    }
    return NO;
}

// for UITextView
-(BOOL)textView:(UITextView*)textView shouldChangeTextInRange:(NSRange)range replacementText:(NSString*)text {
    if ([@"\n" isEqualToString:text]) {
        NSUInteger index = [_inputFields indexOfObject:textView];
        index++;
        if (index < _inputFields.count) {
            UIView *v = [_inputFields objectAtIndex:index];
            [v becomeFirstResponder];
        } else {
            [self.view endEditing:YES];
        }
        return NO;
    }
    return YES;
}

si (cellule == néant)
{
    cell = [[UITableViewCell alloc] initWithStyle: UITableViewCellStyleDefault reuseIdentifier: cellIdentifier];
    txt_Input = [[UITextField alloc] initWithFrame: CGRectMake (0, 10, 150, 30)];
    txt_Input.tag = indexPath.row + 1;
    [self.array_Textfields addObject: txt_Input]; // Initialise le tableau mutable dans ViewDidLoad
}

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

    int tag = (int) textField.tag;
    UITextField * txt = [self.array_Textfields objectAtIndex: tag];
    [txt devenuFirstResponder];
    retourner OUI;
}

J'avais environ 10+ UITextField dans mon story-board et la façon dont j'ai activé la fonctionnalité suivante était de créer un tableau de UITextField et de faire du prochain UITextField le premier répondeur. Voici le fichier d'implémentation:

#import "RegistrationTableViewController.h"

@interface RegistrationTableViewController ()
@property (weak, nonatomic) IBOutlet UITextField *fullNameTextField;
@property (weak, nonatomic) IBOutlet UITextField *addressTextField;
@property (weak, nonatomic) IBOutlet UITextField *address2TextField;
@property (weak, nonatomic) IBOutlet UITextField *cityTextField;
@property (weak, nonatomic) IBOutlet UITextField *zipCodeTextField;
@property (weak, nonatomic) IBOutlet UITextField *urlTextField;
@property (weak, nonatomic) IBOutlet UITextField *usernameTextField;
@property (weak, nonatomic) IBOutlet UITextField *emailTextField;
@property (weak, nonatomic) IBOutlet UITextField *passwordTextField;
@property (weak, nonatomic) IBOutlet UITextField *confirmPWTextField;

@end
NSArray *uiTextFieldArray;
@implementation RegistrationTableViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"view did load");
    uiTextFieldArray = @[self.fullNameTextField,self.addressTextField,self.address2TextField,self.cityTextField,self.zipCodeTextField,self.urlTextField,self.usernameTextField,self.emailTextField,self.passwordTextField,self.confirmPWTextField];
    for(UITextField *myField in uiTextFieldArray){
        myField.delegate = self;
    }


}
-(BOOL)textFieldShouldReturn:(UITextField *)textField{
    long index = [uiTextFieldArray indexOfObject:textField];
    NSLog(@"%ld",index);
    if(index < (uiTextFieldArray.count - 1)){
        [uiTextFieldArray[++index] becomeFirstResponder];
    }else{
        [uiTextFieldArray[index] resignFirstResponder];
    }
    return YES;
}
- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

@end

Cela a fonctionné pour moi dans Xamarin.iOS / Monotouch. Modifiez le bouton du clavier sur Suivant, passez le contrôle au UITextField suivant et masquez le clavier après le dernier UITextField.

private void SetShouldReturnDelegates(IEnumerable<UIView> subViewsToScout )
{
  foreach (var item in subViewsToScout.Where(item => item.GetType() == typeof (UITextField)))
  {
    (item as UITextField).ReturnKeyType = UIReturnKeyType.Next;
    (item as UITextField).ShouldReturn += (textField) =>
    {
        nint nextTag = textField.Tag + 1;
        var nextResponder = textField.Superview.ViewWithTag(nextTag);
        if (null != nextResponder)
            nextResponder.BecomeFirstResponder();
        else
            textField.Superview.EndEditing(true); 
            //You could also use textField.ResignFirstResponder(); 

        return false; // We do not want UITextField to insert line-breaks.
    };
  }
}

À l'intérieur du ViewDidLoad, vous aurez:

Si vos TextFields n'ont pas de balise, définissez-le maintenant:

txtField1.Tag = 0;
txtField2.Tag = 1;
txtField3.Tag = 2;
//...

et juste l'appel

SetShouldReturnDelegates(yourViewWithTxtFields.Subviews.ToList());
//If you are not sure of which view contains your fields you can also call it in a safer way:
SetShouldReturnDelegates(txtField1.Superview.Subviews.ToList());
//You can also reuse the same method with different containerViews in case your UITextField are under different views.

C'est une solution simple et rapide, sans utiliser de tag, pas de trucs de storyboard ...

Utilisez simplement cette extension:

extension UITextField{

    func nextTextFieldField() -> UITextField?{
        //field to return
        var returnField : UITextField?
        if self.superview != nil{
            //for each view in superview
            for (_, view) in self.superview!.subviews.enumerate(){
                //if subview is a text's field
                if view.isKindOfClass(UITextField){
                    //cast curent view as text field
                    let currentTextField = view as! UITextField
                    //if text field is after the current one
                    if currentTextField.frame.origin.y > self.frame.origin.y{
                        //if there is no text field to return already
                        if returnField == nil {
                            //set as default return
                            returnField = currentTextField
                        }
                            //else if this this less far than the other
                        else if currentTextField.frame.origin.y < returnField!.frame.origin.y{
                            //this is the field to return
                            returnField = currentTextField
                        }
                    }
                }
            }
        }
        //end of the mdethod
        return returnField
    }

}

Et appelez-le comme ceci (par exemple) avec votre délégué textfield:

func textFieldShouldReturn(textField: UITextField) -> Bool {
    textField.resignFirstResponder()
    textField.nextTextFieldField()?.becomeFirstResponder()
    return true
}

Une manière plus sûre et plus directe, en supposant:

• les délégués de champ de texte sont définis sur votre contrôleur de vue
• tous les champs de texte sont des sous-vues de la même vue
• les champs de texte ont des balises dans l'ordre dans lequel vous souhaitez progresser (par exemple, textField2.tag = 2, textField3.tag = 3, etc.)
• le passage au champ de texte suivant se produira lorsque vous appuyez sur le bouton de retour du clavier (vous pouvez le changer en suivant , terminé , etc.)
• vous voulez que le clavier disparaisse après le dernier champ de texte

Swift 4.1:

extension ViewController: UITextFieldDelegate {
    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
        let nextTag = textField.tag + 1
        guard let nextTextField = textField.superview?.viewWithTag(nextTag) else {
            textField.resignFirstResponder()
            return false
        }

    nextTextField.becomeFirstResponder()

    return false

    }
}

dans textFieldShouldReturn, vous devez vérifier que le champ de texte sur lequel vous vous trouvez n'est pas le dernier lorsqu'il clique ensuite et si ce n'est pas le cas, ne fermez pas le clavier.

Ceci est un ancien message, mais a un rang de page élevé, je vais donc carillon avec ma solution.

J'ai eu un problème similaire et j'ai fini par créer une sous-classe de UIToolbarpour gérer la fonctionnalité suivante / précédente / terminée dans une table dynamique avec des sections: https://github.com/jday001/DataEntryToolbar

Vous définissez la barre d'outils comme inputAccessoryView de vos champs de texte et les ajoutez à son dictionnaire. Cela vous permet de les parcourir en avant et en arrière, même avec du contenu dynamique. Il existe des méthodes déléguées si vous souhaitez déclencher votre propre fonctionnalité lorsque la navigation textField se produit, mais vous n'avez pas à gérer la gestion des balises ou l'état du premier répondant.

Il y a des extraits de code et un exemple d'application sur le lien GitHub pour vous aider avec les détails d'implémentation. Vous aurez besoin de votre propre modèle de données pour garder une trace des valeurs à l'intérieur des champs.

Sans utiliser de balises et sans ajouter de propriété pour nextField / nextTextField, vous pouvez essayer ceci pour émuler TAB, où "testInput" est votre champ actif actuel:

if ([textInput isFirstResponder])
    [textInput.superview.subviews enumerateObjectsAtIndexes:
     [NSIndexSet indexSetWithIndexesInRange:
      NSMakeRange([textInput.superview.subviews indexOfObject:textInput]+1,
                  [textInput.superview.subviews count]-[textInput.superview.subviews indexOfObject:textInput]-1)]
                                                    options:0 usingBlock:^(UIView *obj, NSUInteger idx, BOOL *stop) {
                                                        *stop = !obj.hidden && [obj becomeFirstResponder];
                                                    }];
if ([textInput isFirstResponder])
    [textInput.superview.subviews enumerateObjectsAtIndexes:
     [NSIndexSet indexSetWithIndexesInRange:
      NSMakeRange(0,
                  [textInput.superview.subviews indexOfObject:textInput])]
                                                    options:0 usingBlock:^(UIView *obj, NSUInteger idx, BOOL *stop) {
                                                        *stop = !obj.hidden && [obj becomeFirstResponder];
                                                    }];

J'utilise la réponse de Michael G. Emmons depuis environ un an maintenant, ça marche très bien. J'ai remarqué récemment que l'appel à resignFirstResponder puis à devientFirstResponder immédiatement peut provoquer un "pépin" du clavier, disparaissant puis apparaissant immédiatement. J'ai légèrement changé sa version pour ignorer le resignFirstResponder si le nextField est disponible.

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

    if ([textField isKindOfClass: [NRTextField class]]))
    {
        NRTextField * nText = (NRTextField *) textField;
        if ([nText nextField]! = nil) {
            dispatch_async (dispatch_get_main_queue (),
                           ^ {[[nText nextField] devientFirstResponder]; });

        }
        autre{
            [textField resignFirstResponder];
        }
    }
    autre{
        [textField resignFirstResponder];
    }

    return true;

}