Come navigare nei campi di testo (pulsanti Avanti / Fine)

Come posso navigare attraverso tutti i miei campi di testo con il pulsante "Avanti" sulla tastiera dell'iPhone?

L'ultimo campo di testo dovrebbe chiudere la tastiera.

Ho installato l'IB the Buttons (Next / Done) ma ora sono bloccato.

Ho implementato l'azione textFieldShouldReturn ma ora i pulsanti Next e Done chiudono la tastiera.

In Cocoa per Mac OS X, hai la prossima catena di responder, dove puoi chiedere al campo di testo quale controllo dovrebbe avere il focus successivo. Questo è ciò che fa funzionare la tabulazione tra i campi di testo. Ma poiché i dispositivi iOS non hanno una tastiera, solo un tocco, questo concetto non è sopravvissuto al passaggio a Cocoa Touch.

Questo può essere fatto facilmente comunque, con due ipotesi:

1. Tutti i "tababable" UITextFieldsono nella stessa vista principale.
2. Il loro "ordine di tabulazione" è definito dalla proprietà tag.

Supponendo che sia possibile sovrascrivere textFieldShouldReturn: come questo:

-(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.
}

Aggiungi altro codice e anche le ipotesi possono essere ignorate.

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
}

Se la superview del campo di testo sarà una UITableViewCell, il prossimo risponditore sarà

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

C'è una soluzione molto più elegante che mi ha lasciato senza fiato la prima volta che l'ho visto. Benefici:

• Più vicino all'implementazione del campo di testo OSX in cui un campo di testo sa dove concentrarsi sul prossimo obiettivo
• Non si basa sull'impostazione o sull'utilizzo di tag, ovvero IMO fragile per questo caso d'uso
• Può essere esteso per funzionare con entrambi UITextFielde UITextViewcontrolli o con qualsiasi controllo dell'interfaccia utente di immissione da tastiera
• Non ingombra il controller della vista con il codice delegato UITextField della piastra di caldaia
• Si integra perfettamente con IB e può essere configurato tramite la familiare opzione drag-drop per collegare le prese.

Creare una sottoclasse UITextField che ha una IBOutletproprietà chiamata nextField. Ecco l'intestazione:

@interface SOTextField : UITextField

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

@end

Ed ecco l'implementazione:

@implementation SOTextField

@end

Nel controller della vista, creerai il -textFieldShouldReturn:metodo delegato:

- (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;
}

In IB, cambia i tuoi UITextFields per usare la SOTextFieldclasse. Successivamente, anche in IB, imposta il delegato per ciascuno dei "SOTextFields" su "File's Owner" (che è proprio dove metti il ​​codice per il metodo delegato - textFieldShouldReturn). La bellezza di questo design è che ora puoi semplicemente fare clic con il pulsante destro del mouse su qualsiasi campo di testo e assegnare la presa nextField SOTextFieldall'oggetto successivo che vuoi essere il prossimo risponditore.

Inoltre, puoi fare cose fantastiche come il loop dei campi di testo in modo che dopo l'ultimo perde il focus, il primo riceverà di nuovo il focus.

Questo può essere facilmente esteso per assegnare automaticamente l' returnKeyTypedel SOTextFieldad un UIReturnKeyNextse c'è un nextField assegnato - una cosa in meno Configura manualmente.

Eccone uno senza delega:

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];

Funziona usando l'azione (per lo più sconosciuta) UIControlEventEditingDidEndOnExit UITextField.

Puoi anche collegarlo facilmente nello storyboard, quindi non è richiesta alcuna delega o codice.

Modifica: in realtà non riesco a capire come collegarlo nello storyboard. becomeFirstRespondernon sembra essere un'azione offerta per questo evento di controllo, che è un peccato. Tuttavia, puoi collegare tutti i tuoi campi di testo a un'unica azione nel ViewController che determina quindi quale campo di testo si becomeFirstResponderbasa sul mittente (anche se non è elegante come la soluzione programmatica sopra, quindi IMO lo fa con il codice sopra riportato viewDidLoad).

Ecco la mia soluzione per questo problema.

Per risolvere questo problema (e poiché odio fare affidamento sui tag per fare cose) ho deciso di aggiungere una proprietà personalizzata all'oggetto UITextField. In altre parole, ho creato una categoria su UITextField in questo modo:

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

Ora, ecco come lo uso:

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

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

E implementare il metodo textFieldShouldReturn:

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

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

    return NO; 
}

Ora ho una specie di elenco collegato di UITextField, ognuno sapendo chi è il prossimo nella linea.

Spero che ti sia d'aiuto.

Un'estensione rapida che applica la risposta di mxcl per renderlo particolarmente facile (adattato a rapido 2.3 da 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)
    }
}

È facile da usare:

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

L'estensione imposterà il pulsante di ritorno su "Avanti" per tutti tranne l'ultimo campo e su "Fine" per l'ultimo campo e sposta lo stato attivo / elimina la tastiera quando vengono toccati.

Swift <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: utilizzare in questo modo -

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

Un modo più coerente e affidabile consiste nell'utilizzare NextResponderTextField È possibile configurarlo totalmente dal generatore di interfaccia senza la necessità di impostare il delegato o di utilizzarlo view.tag.

Tutto quello che devi fare è

1. Impostare il tipo di classe del vostro UITextFieldessereNextResponderTextField
2. Quindi impostare l'uscita di nextResponderFieldper puntare al risponditore successivo che può essere qualsiasi UITextFieldo UIRespondersottoclasse. Può anche essere un UIButton e la libreria è abbastanza intelligente da attivare l' TouchUpInsideevento del pulsante solo se è abilitato.

Ecco la libreria in azione:

Mi piacciono le soluzioni OO che sono già state suggerite da Anth0 e Answerbot. Tuttavia, stavo lavorando su un POC veloce e piccolo, quindi non volevo ingombrare le cose con sottoclassi e categorie.

Un'altra soluzione semplice è quella di creare un NSArray di campi e cercare il campo successivo quando si preme next. Non una soluzione OO, ma rapida, semplice e facile da implementare. Inoltre, puoi vedere e modificare l'ordinazione a colpo d'occhio.

Ecco il mio codice (basato su altre risposte in questo thread):

@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;
}

• Restituisco sempre NO perché non voglio inserire un'interruzione di riga. Ho pensato di segnalarlo da quando ho restituito SÌ che usciva automaticamente dai campi successivi o inseriva un'interruzione di riga in TextView. Mi ci è voluto un po 'di tempo per capirlo.
• activeField tiene traccia del campo attivo nel caso in cui sia necessario lo scorrimento per sbloccare il campo dalla tastiera. Se hai un codice simile, assicurati di assegnare activeField prima di cambiare il primo risponditore. La modifica del primo risponditore è immediata e genererà immediatamente l'evento KeyboardWasShown.

Ecco un'implementazione della tabulazione usando una categoria su UIControl. Questa soluzione ha tutti i vantaggi dei metodi di Michael e Anth0, ma funziona per tutti gli UIControls, non solo per UITextFields. Funziona anche perfettamente con Interface Builder e storyboard.

App di origine e di esempio: repository GitHub per UIControlsWithTabbing

Uso:

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

Intestazione:

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

#import <UIKit/UIKit.h>

@interface UIControl (NextControl)

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

- (BOOL)transferFirstResponderToNextControl;

@end

Implementazione:

#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

Ho provato molti codici e, alla fine, questo ha funzionato per me in Swift 3.0 Latest [marzo 2017]

La ViewControllerclasse dovrebbe essere ereditata UITextFieldDelegateper far funzionare questo codice.

class ViewController: UIViewController,UITextFieldDelegate  

Aggiungi il campo Testo con il numero di Tag corretto e questo numero di tag viene utilizzato per portare il controllo al campo di testo appropriato in base al numero di tag incrementale assegnato ad esso.

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

Nel codice sopra, il punto in returnKeyType = UIReturnKeyType.nextcui verrà visualizzata la chiave di ritorno del tastierino poiché Nextsono disponibili anche altre opzioni come Join/Goecc., In base all'applicazione, cambiano i valori.

Questo textFieldShouldReturnè un metodo di UITextFieldDelegate controllato e qui abbiamo la selezione del campo successivo in base all'incremento del valore Tag

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
 }

Dopo essere usciti da un campo di testo, si chiama [otherTextField ontoFirstResponder] e il campo successivo diventa attivo.

Questo può effettivamente essere un problema difficile da affrontare poiché spesso vorrai anche scorrere lo schermo o regolare in altro modo la posizione del campo di testo in modo che sia facile da vedere durante la modifica. Assicurati di fare molti test entrando e uscendo dai campi di testo in diversi modi e anche uscendo presto (dai sempre all'utente la possibilità di chiudere la tastiera invece di passare al campo successivo, di solito con "Fine" in la barra di navigazione)

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

Un metodo molto semplice per chiudere la tastiera quando viene premuto il pulsante "Fine" è:

Crea una nuova IBAction nell'intestazione

- (IBAction)textFieldDoneEditing:(id)sender;

Nel file di implementazione (file .m) aggiungi il seguente metodo:

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

Quindi, quando vieni a collegare l'IBAction al campo di testo, collega l'evento "Did End On Exit".

Per prima cosa imposta il tasto Invio della tastiera in xib, altrimenti puoi scrivere il codice in 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;
}

Sono sorpreso da quante risposte qui non riescono a capire un semplice concetto: navigare attraverso i controlli nella tua app non è qualcosa che le viste stesse dovrebbero fare. E 'il regolatore di lavoro s' per decidere quale di controllo per rendere il prossimo primo soccorritore.

Inoltre, la maggior parte delle risposte si applicava solo alla navigazione in avanti, ma gli utenti potrebbero anche voler tornare indietro.

Quindi, ecco cosa ho pensato. Il modulo deve essere gestito da un controller di visualizzazione e i controller di visualizzazione fanno parte della catena di responder. Quindi sei perfettamente libero di implementare i seguenti metodi:

#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];
}

Potrebbero essere applicate ulteriori logiche per lo scorrimento dei risponditori fuori schermo visibili in anticipo.

Un altro vantaggio di questo approccio è che non hai bisogno di sottoclassare tutti i tipi di controlli che potresti voler visualizzare (come UITextField) ma puoi invece gestire la logica a livello di controller, dove, siamo sinceri, è il posto giusto per farlo .

Ho aggiunto alla risposta di PeyloW nel caso in cui stai cercando di implementare una funzionalità pulsante precedente / successivo:

- (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];

    }
}

Dove si esegue la sottoclasse dell'UIView in questo modo:

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

Ciao a tutti, per favore, vedi questo

- (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;    
  }
}

Ho provato a risolvere questo problema utilizzando un approccio più sofisticato basato sull'assegnazione di ogni cella (o UITextField) in un UITableViewvalore di tag univoco che può essere successivamente recuperato: activ-next-uitextfield-in-uitableview-ios

Spero che questo possa essere d'aiuto!

Ho appena creato un nuovo Pod quando ho a che fare con queste cose GNTextFieldsCollectionManager . Gestisce automaticamente il prossimo / ultimo problema textField ed è molto facile da usare:

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

Cattura tutti i campi di testo ordinati comparendo nella gerarchia di visualizzazione (o per tag), oppure puoi specificare il tuo array di campi di testo.

Soluzione in Swift 3.1, dopo aver collegato i campi di testo IBOutlet imposta il delegato dei campi di testo in viewDidLoad, quindi naviga nell'azione in 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
        }

    }

Se qualcuno vuole così. Penso che questo sia il più vicino ai requisiti richiesti in questione

Ecco come ho implementato questo

Aggiungi vista accessori per ogni campo di testo per il quale desideri configurare, usando

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
}

Utilizzare le seguenti funzioni per gestire i tocchi

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
}

Dovrai dare i tag textFields in sequenza in cui vuoi che il pulsante next / prev risponda.

Preferisco piuttosto:

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

Nel file NIB aggancio i textField nell'ordine desiderato in questo array inputFields. Dopodiché eseguo un semplice test per l'indice di UITextField che segnala che l'utente ha toccato return:

// 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;
}

if (cella == zero)
{
    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]; // Inizializza array mutabile in ViewDidLoad
}

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

    int tag = (int) textField.tag;
    UITextField * txt = [self.array_Textfields objectAtIndex: tag];
    [txt diventareFirstResponder];
    ritorno SÌ;
}

Avevo circa 10+ UITextField nella mia storyboard e il modo in cui abilitavo la prossima funzionalità era creando un array di UITextField e rendendo il prossimo UITextField il primoRisponditore. Ecco il file di implementazione:

#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

Questo ha funzionato per me in Xamarin.iOS / Monotouch. Modificare il pulsante della tastiera su Avanti, passare il controllo al successivo UITextField e nascondere la tastiera dopo l'ultimo 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.
    };
  }
}

All'interno di ViewDidLoad avrai:

Se i tuoi campi di testo non hanno un tag, impostalo ora:

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

e solo la chiamata

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.

Questa è una soluzione semplice in breve tempo, senza tag usando, senza trucchi storyboard ...

Usa questa estensione:

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
    }

}

E chiamalo così (ad esempio) con il tuo delegato del campo di testo:

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

Un modo più sicuro e diretto, assumendo:

• i delegati dei campi di testo sono impostati sul controller della vista
• tutti i campi di testo sono viste secondarie della stessa vista
• i campi di testo hanno i tag nell'ordine in cui vuoi progredire (ad es. textField2.tag = 2, textField3.tag = 3, ecc.)
• lo spostamento al campo di testo successivo avverrà quando tocchi il pulsante di ritorno sulla tastiera (puoi cambiarlo in successivo , fatto , ecc.)
• vuoi che la tastiera venga chiusa dopo l'ultimo campo di testo

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

    }
}

in textFieldShouldReturn dovresti verificare che il campo di testo in cui ti trovi attualmente non sia l'ultimo quando fanno clic su successivo e se non è in grado di chiudere la tastiera.

Questo è un vecchio post, ma ha un alto rango di pagine, quindi entrerò nella mia soluzione.

Ho avuto un problema simile e ho finito per creare una sottoclasse di UIToolbarper gestire la funzionalità successiva / precedente / completata in una tabella dinamica Visualizza sezioni: https://github.com/jday001/DataEntryToolbar

Impostare la barra degli strumenti come inputAccessoryView dei campi di testo e aggiungerli al dizionario. Ciò consente di spostarli avanti e indietro, anche con contenuti dinamici. Esistono metodi delegati se si desidera attivare la propria funzionalità quando si verifica la navigazione di textField, ma non è necessario gestire la gestione di tag o lo stato del primo risponditore.

Ci sono frammenti di codice e un'app di esempio sul link GitHub per aiutare con i dettagli di implementazione. Avrai bisogno del tuo modello di dati per tenere traccia dei valori all'interno dei campi.

Senza tag di utilizzo e senza aggiungere una proprietà per nextField / nextTextField, puoi provare questo per emulare TAB, dove "testInput" è il tuo campo attivo corrente:

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];
                                                    }];

Sto usando la risposta di Michael G. Emmons da circa un anno, funziona benissimo. Di recente ho notato che chiamare immediatamente resignFirstResponder e poi diventareFirstResponder può causare il "glitch" della tastiera, la sua scomparsa e la sua comparsa immediata. Ho modificato leggermente la sua versione per saltare resignFirstResponder se il prossimo campo è disponibile.

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

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

        }
        altro{
            [textField resignFirstResponder];
        }
    }
    altro{
        [textField resignFirstResponder];
    }

    ritorno vero;

}