Ich versuche, die Standardaktion der Zurück-Schaltfläche in einem Navigationscontroller zu überschreiben. Ich habe einem Ziel eine Aktion auf der benutzerdefinierten Schaltfläche bereitgestellt. Das Seltsame ist, wenn es zugewiesen wird, obwohl das Backbutton-Attribut es ihnen nicht beachtet und es nur die aktuelle Ansicht öffnet und zum Stamm zurückkehrt:

UIBarButtonItem *backButton = [[UIBarButtonItem alloc] 
                                  initWithTitle: @"Servers" 
                                  style:UIBarButtonItemStylePlain 
                                  target:self 
                                  action:@selector(home)];
self.navigationItem.backBarButtonItem = backButton;

Sobald ich es durch das leftBarButtonItemauf eingestellt navigationItemhabe, ruft es meine Aktion auf, aber dann sieht der Knopf wie ein einfacher runder aus, anstatt wie der mit einem Pfeil nach hinten:

self.navigationItem.leftBarButtonItem = backButton;

Wie kann ich meine benutzerdefinierte Aktion aufrufen, bevor ich zur Stammansicht zurückkehre? Gibt es eine Möglichkeit, die Standard-Back-Aktion zu überschreiben, oder gibt es eine Methode, die beim Verlassen einer Ansicht immer aufgerufen wird ( viewDidUnloadfunktioniert das nicht)?

Versuchen Sie, dies in den Ansichts-Controller zu legen, in dem Sie die Presse erkennen möchten:

-(void) viewWillDisappear:(BOOL)animated {
    if ([self.navigationController.viewControllers indexOfObject:self]==NSNotFound) {
       // back button was pressed.  We know this is true because self is no longer
       // in the navigation stack.  
    }
    [super viewWillDisappear:animated];
}

Ich habe die Erweiterung UIViewController-BackButtonHandler implementiert . Es muss nichts unterklassifiziert werden. Fügen Sie es einfach in Ihr Projekt ein und überschreiben Sie die navigationShouldPopOnBackButtonMethode in der UIViewControllerKlasse:

-(BOOL) navigationShouldPopOnBackButton {
    if(needsShowConfirmation) {
        // Show confirmation alert
        // ...
        return NO; // Ignore 'Back' button this time
    }
    return YES; // Process 'Back' button click and Pop view controler
}

Beispiel-App herunterladen .

Anders als Amagrammer sagte, ist es möglich. Sie müssen Ihre Unterklasse navigationController. Ich habe hier alles erklärt (einschließlich Beispielcode).

Schnelle Version:

(von https://stackoverflow.com/a/19132881/826435 )

In Ihrem View Controller passen Sie sich einfach einem Protokoll an und führen alle erforderlichen Aktionen aus:

extension MyViewController: NavigationControllerBackButtonDelegate {
    func shouldPopOnBackButtonPress() -> Bool {
        performSomeActionOnThePressOfABackButton()
        return false
    }
}

Erstellen Sie dann beispielsweise eine Klasse NavigationController+BackButtonund kopieren Sie einfach den folgenden Code:

protocol NavigationControllerBackButtonDelegate {
    func shouldPopOnBackButtonPress() -> Bool
}

extension UINavigationController {
    public func navigationBar(_ navigationBar: UINavigationBar, shouldPop item: UINavigationItem) -> Bool {
        // Prevents from a synchronization issue of popping too many navigation items
        // and not enough view controllers or viceversa from unusual tapping
        if viewControllers.count < navigationBar.items!.count {
            return true
        }

        // Check if we have a view controller that wants to respond to being popped
        var shouldPop = true
        if let viewController = topViewController as? NavigationControllerBackButtonDelegate {
            shouldPop = viewController.shouldPopOnBackButtonPress()
        }

        if (shouldPop) {
            DispatchQueue.main.async {
                self.popViewController(animated: true)
            }
        } else {
            // Prevent the back button from staying in an disabled state
            for view in navigationBar.subviews {
                if view.alpha < 1.0 {
                    UIView.animate(withDuration: 0.25, animations: {
                        view.alpha = 1.0
                    })
                }
            }

        }

        return false
    }
}

Es ist nicht möglich, direkt zu tun. Es gibt ein paar Alternativen:

1. Erstellen Sie Ihre eigene Benutzerdefinierung UIBarButtonItem, die beim Tippen validiert und angezeigt wird, wenn der Test erfolgreich ist
2. Überprüfen Sie den Inhalt des Formularfelds mit einer UITextFieldDelegatmethode, z. B. -textFieldShouldReturn:die aufgerufen wird, nachdem die Taste Returnoder Doneauf der Tastatur gedrückt wurde

Der Nachteil der ersten Option ist, dass auf den nach links zeigenden Pfeil der Zurück-Schaltfläche nicht über eine benutzerdefinierte Leistenschaltfläche zugegriffen werden kann. Sie müssen also ein Bild verwenden oder eine normale Stilschaltfläche verwenden.

Die zweite Option ist hilfreich, da Sie das Textfeld in der Delegate-Methode zurückerhalten, sodass Sie Ihre Validierungslogik auf das spezifische Textfeld ausrichten können, das an die Delegate-Rückrufmethode gesendet wird.

Aus einigen Threading-Gründen war die von @HansPinckaers erwähnte Lösung nicht richtig für mich, aber ich habe einen sehr einfacheren Weg gefunden, den Touch-Button zu berühren, und ich möchte dies hier festhalten, falls dies stundenlange Täuschungen vermeiden könnte jemand anderes. Der Trick ist wirklich einfach: Fügen Sie einfach einen transparenten UIButton als Unteransicht zu Ihrer UINavigationBar hinzu und stellen Sie Ihre Selektoren für ihn so ein, als wäre es die echte Schaltfläche! Hier ist ein Beispiel mit Monotouch und C #, aber die Übersetzung in Objective-C sollte nicht zu schwer zu finden sein.

public class Test : UIViewController {
    public override void ViewDidLoad() {
        UIButton b = new UIButton(new RectangleF(0, 0, 60, 44)); //width must be adapted to label contained in button
        b.BackgroundColor = UIColor.Clear; //making the background invisible
        b.Title = string.Empty; // and no need to write anything
        b.TouchDown += delegate {
            Console.WriteLine("caught!");
            if (true) // check what you want here
                NavigationController.PopViewControllerAnimated(true); // and then we pop if we want
        };
        NavigationController.NavigationBar.AddSubview(button); // insert the button to the nav bar
    }
}

Unterhaltsame Tatsache: Zu Testzwecken und um gute Abmessungen für meinen gefälschten Knopf zu finden, habe ich seine Hintergrundfarbe auf Blau gesetzt ... Und sie wird hinter dem Zurück-Knopf angezeigt! Wie auch immer, es fängt immer noch jede Berührung auf, die auf die ursprüngliche Taste abzielt.

Mit dieser Technik können Sie den Text der Schaltfläche "Zurück" ändern, ohne den Titel eines der Ansichts-Controller zu beeinflussen oder zu sehen, wie sich der Text der Schaltfläche "Zurück" während der Animation ändert.

Fügen Sie dies der init-Methode im aufrufenden View-Controller hinzu:

UIBarButtonItem *temporaryBarButtonItem = [[UIBarButtonItem alloc] init];   
temporaryBarButtonItem.title = @"Back";
self.navigationItem.backBarButtonItem = temporaryBarButtonItem;
[temporaryBarButtonItem release];

Einfachster Weg

Sie können die Delegatmethoden des UINavigationController verwenden. Die Methode willShowViewControllerwird aufgerufen, wenn die Zurück-Taste Ihres VC gedrückt wird. Tun Sie, was Sie wollen, wenn Sie die Zurück-Taste drücken

- (void)navigationController:(UINavigationController *)navigationController willShowViewController:(UIViewController *)viewController animated:(BOOL)animated;

Hier ist meine Swift-Lösung. Überschreiben Sie in Ihrer Unterklasse von UIViewController die Methode navigationShouldPopOnBackButton.

extension UIViewController {
    func navigationShouldPopOnBackButton() -> Bool {
        return true
    }
}

extension UINavigationController {

    func navigationBar(navigationBar: UINavigationBar, shouldPopItem item: UINavigationItem) -> Bool {
        if let vc = self.topViewController {
            if vc.navigationShouldPopOnBackButton() {
                self.popViewControllerAnimated(true)
            } else {
                for it in navigationBar.subviews {
                    let view = it as! UIView
                    if view.alpha < 1.0 {
                        [UIView .animateWithDuration(0.25, animations: { () -> Void in
                            view.alpha = 1.0
                        })]
                    }
                }
                return false
            }
        }
        return true
    }

}

Es wurde eine Lösung gefunden, die auch den Stil der Zurück-Schaltfläche beibehält. Fügen Sie Ihrem View Controller die folgende Methode hinzu.

-(void) overrideBack{

    UIButton *transparentButton = [[UIButton alloc] init];
    [transparentButton setFrame:CGRectMake(0,0, 50, 40)];
    [transparentButton setBackgroundColor:[UIColor clearColor]];
    [transparentButton addTarget:self action:@selector(backAction:) forControlEvents:UIControlEventTouchUpInside];
    [self.navigationController.navigationBar addSubview:transparentButton];


}

Stellen Sie nun eine Funktion bereit, die für die folgende Methode erforderlich ist:

-(void)backAction:(UIBarButtonItem *)sender {
    //Your functionality
}

Alles was es tut ist den hinteren Knopf mit einem transparenten Knopf abzudecken;)

Überschreiben der Navigationsleiste (_ navigationBar: shouldPop) : Dies ist keine gute Idee, auch wenn sie funktioniert. Für mich verursachte es zufällige Abstürze beim Zurücknavigieren. Ich empfehle Ihnen, die Schaltfläche "Zurück" einfach zu überschreiben, indem Sie die Standard-Schaltfläche "Zurück" aus dem Navigationselement entfernen und eine benutzerdefinierte Schaltfläche "Zurück" wie folgt erstellen:

override func viewDidLoad(){
   super.viewDidLoad()
   
   navigationItem.leftBarButton = .init(title: "Go Back", ... , action: #selector(myCutsomBackAction) 

   ...
 
}

=======================================

Aufbauend auf früheren Antworten mit UIAlert in Swift5 auf asynchrone Weise

protocol NavigationControllerBackButtonDelegate {
    func shouldPopOnBackButtonPress(_ completion: @escaping (Bool) -> ())
}

extension UINavigationController: UINavigationBarDelegate {
    public func navigationBar(_ navigationBar: UINavigationBar, shouldPop item: UINavigationItem) -> Bool {
      
        if viewControllers.count < navigationBar.items!.count {
            return true
        }
        
        // Check if we have a view controller that wants to respond to being popped
        
        if let viewController = topViewController as? NavigationControllerBackButtonDelegate {
            
            viewController.shouldPopOnBackButtonPress { shouldPop in
                if (shouldPop) {
                    /// on confirm => pop
                    DispatchQueue.main.async {
                        self.popViewController(animated: true)
                    }
                } else {
                    /// on cancel => do nothing
                }
            }
            /// return false => so navigator will cancel the popBack
            /// until user confirm or cancel
            return false
        }else{
            DispatchQueue.main.async {
                self.popViewController(animated: true)
            }
        }
        return true
    }
}

Auf Ihrem Controller

extension MyController: NavigationControllerBackButtonDelegate {
    
    func shouldPopOnBackButtonPress(_ completion: @escaping (Bool) -> ()) {
    
        let msg = "message"
        
        /// show UIAlert
        alertAttention(msg: msg, actions: [
            
            .init(title: "Continuer", style: .destructive, handler: { _ in
                completion(true)
            }),
            .init(title: "Annuler", style: .cancel, handler: { _ in
                completion(false)
            })
            ])
   
    }

}

Ich glaube nicht, dass dies leicht möglich ist. Ich glaube, der einzige Weg, dies zu umgehen, besteht darin, ein eigenes Pfeilbild mit der Zurück-Taste zu erstellen, um es dort oben zu platzieren. Anfangs war es für mich frustrierend, aber ich verstehe, warum es aus Gründen der Konsistenz weggelassen wurde.

Sie können schließen (ohne den Pfeil), indem Sie eine reguläre Schaltfläche erstellen und die Standard-Zurück-Schaltfläche ausblenden:

self.navigationItem.leftBarButtonItem = [[[UIBarButtonItem alloc] initWithTitle:@"Servers" style:UIBarButtonItemStyleDone target:nil action:nil] autorelease];
self.navigationItem.hidesBackButton = YES;

Es gibt einen einfacheren Weg, indem Sie einfach die Delegate-Methode von unterordnenUINavigationBar und die Methode überschreiben .ShouldPopItem

Die Lösung von onegray ist nicht sicher. Laut den offiziellen Dokumenten von Apple, https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/CustomizingExistingClasses/CustomizingExistingClasses.html , sollten wir dies vermeiden.

"Wenn der Name einer in einer Kategorie deklarierten Methode mit einer Methode in der ursprünglichen Klasse oder einer Methode in einer anderen Kategorie in derselben Klasse (oder sogar einer Oberklasse) identisch ist, ist das Verhalten hinsichtlich der verwendeten Methodenimplementierung undefiniert zur Laufzeit. Dies ist weniger wahrscheinlich, wenn Sie Kategorien mit Ihren eigenen Klassen verwenden, kann jedoch Probleme verursachen, wenn Sie Kategorien verwenden, um Methoden zu Standardklassen von Cocoa oder Cocoa Touch hinzuzufügen. "

Verwenden von Swift:

override func viewWillDisappear(animated: Bool) {
    super.viewWillDisappear(animated)
    if self.navigationController?.topViewController != self {
        print("back button tapped")
    }
}

Hier ist die Swift 3-Version von @oneways Antwort zum Abfangen des Ereignisses der Zurück-Schaltfläche der Navigationsleiste, bevor es ausgelöst wird. Da UINavigationBarDelegatedies nicht verwendet werden kann UIViewController, müssen Sie einen Delegaten erstellen, der beim navigationBar shouldPopAufruf ausgelöst wird.

@objc public protocol BackButtonDelegate {
      @objc optional func navigationShouldPopOnBackButton() -> Bool 
}

extension UINavigationController: UINavigationBarDelegate  {

    public func navigationBar(_ navigationBar: UINavigationBar, shouldPop item: UINavigationItem) -> Bool {

        if viewControllers.count < (navigationBar.items?.count)! {                
            return true
        }

        var shouldPop = true
        let vc = self.topViewController

        if vc.responds(to: #selector(vc.navigationShouldPopOnBackButton)) {
            shouldPop = vc.navigationShouldPopOnBackButton()
        }

        if shouldPop {
            DispatchQueue.main.async {
                self.popViewController(animated: true)
            }
        } else {
            for subView in navigationBar.subviews {
                if(0 < subView.alpha && subView.alpha < 1) {
                    UIView.animate(withDuration: 0.25, animations: {
                        subView.alpha = 1
                    })
                }
            }
        }

        return false
    }
}

Fügen Sie dann in Ihrem Ansichts-Controller die Delegatenfunktion hinzu:

class BaseVC: UIViewController, BackButtonDelegate {
    func navigationShouldPopOnBackButton() -> Bool {
        if ... {
            return true
        } else {
            return false
        }        
    }
}

Ich habe festgestellt, dass wir häufig einen Alarm-Controller hinzufügen möchten, damit Benutzer entscheiden können, ob sie zurückkehren möchten. Wenn ja, können Sie immer return falsein navigationShouldPopOnBackButton()Funktion und schließen Sie die View - Controller durch so etwas wie dies zu tun:

func navigationShouldPopOnBackButton() -> Bool {
     let alert = UIAlertController(title: "Warning",
                                          message: "Do you want to quit?",
                                          preferredStyle: .alert)
            alert.addAction(UIAlertAction(title: "Yes", style: .default, handler: { UIAlertAction in self.yes()}))
            alert.addAction(UIAlertAction(title: "No", style: .cancel, handler: { UIAlertAction in self.no()}))
            present(alert, animated: true, completion: nil)
      return false
}

func yes() {
     print("yes")
     DispatchQueue.main.async {
            _ = self.navigationController?.popViewController(animated: true)
        }
}

func no() {
    print("no")       
}

Swift 4 iOS 11.3 Version:

Dies baut auf der Antwort von kgaidis von https://stackoverflow.com/a/34343418/4316579 auf

Ich bin nicht sicher, wann die Erweiterung nicht mehr funktioniert, aber zum Zeitpunkt dieses Schreibens (Swift 4) scheint es, dass die Erweiterung nicht mehr ausgeführt wird, es sei denn, Sie erklären die UINavigationBarDelegate-Konformität wie unten beschrieben.

Ich hoffe, dies hilft Menschen, die sich fragen, warum ihre Erweiterung nicht mehr funktioniert.

extension UINavigationController: UINavigationBarDelegate {
    public func navigationBar(_ navigationBar: UINavigationBar, shouldPop item: UINavigationItem) -> Bool {

    }
}

Wenn Sie die Ziel- und Aktionsvariablen verwenden, die Sie derzeit 'nil' verlassen, sollten Sie in der Lage sein, Ihre Speicherdialoge so zu verkabeln, dass sie aufgerufen werden, wenn die Schaltfläche "ausgewählt" ist. Achtung, dies kann in seltsamen Momenten ausgelöst werden.

Ich stimme größtenteils mit Amagrammer überein, aber ich denke nicht, dass es so schwierig wäre, die Schaltfläche mit dem Pfeil benutzerdefiniert zu machen. Ich würde einfach die Zurück-Schaltfläche umbenennen, einen Screenshot machen, die benötigte Schaltflächengröße in Photoshop bearbeiten und das Bild oben auf Ihrer Schaltfläche haben.

Sie können versuchen, auf das Element "NavigationBars Right Button" zuzugreifen und dessen Selector-Eigenschaft festzulegen. Hier ist eine Referenz- UIBarButtonItem-Referenz . Wenn dies nicht funktioniert, setzen Sie das rechte Schaltflächenelement der Navigationsleiste auf ein benutzerdefiniertes UIBarButtonItem, das Sie verwenden erstelle und setze seinen Selektor ... hoffe das hilft

Für ein Formular, für das Benutzereingaben wie diese erforderlich sind, würde ich empfehlen, es als "modal" anstelle eines Teils Ihres Navigationsstapels aufzurufen. Auf diese Weise müssen sie sich um das Geschäft auf dem Formular kümmern, dann können Sie es validieren und über eine benutzerdefinierte Schaltfläche schließen. Sie können sogar eine Navigationsleiste entwerfen, die genauso aussieht wie der Rest Ihrer App, Ihnen jedoch mehr Kontrolle bietet.

Um die Schaltfläche Zurück abzufangen, bedecken Sie sie einfach mit einem transparenten UIControl und fangen Sie die Berührungen ab.

@interface MyViewController : UIViewController
{
    UIControl   *backCover;
    BOOL        inhibitBackButtonBOOL;
}
@end

@implementation MyViewController
-(void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];

    // Cover the back button (cannot do this in viewWillAppear -- too soon)
    if ( backCover == nil ) {
        backCover = [[UIControl alloc] initWithFrame:CGRectMake( 0, 0, 80, 44)];
#if TARGET_IPHONE_SIMULATOR
        // show the cover for testing
        backCover.backgroundColor = [UIColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:0.15];
#endif
        [backCover addTarget:self action:@selector(backCoverAction) forControlEvents:UIControlEventTouchDown];
        UINavigationBar *navBar = self.navigationController.navigationBar;
        [navBar addSubview:backCover];
    }
}

-(void)viewWillDisappear:(BOOL)animated
{
    [super viewWillDisappear:animated];

    [backCover removeFromSuperview];
    backCover = nil;
}

- (void)backCoverAction
{
    if ( inhibitBackButtonBOOL ) {
        NSLog(@"Back button aborted");
        // notify the user why...
    } else {
        [self.navigationController popViewControllerAnimated:YES]; // "Back"
    }
}
@end

Zumindest in Xcode 5 gibt es eine einfache und ziemlich gute (nicht perfekte) Lösung. Ziehen Sie in IB ein Balkenschaltflächenelement aus dem Bereich "Dienstprogramme" und legen Sie es auf der linken Seite der Navigationsleiste ab, wo sich die Schaltfläche "Zurück" befinden würde. Setzen Sie das Etikett auf "Zurück". Sie haben eine funktionierende Schaltfläche, die Sie mit Ihrer IBAction verknüpfen und Ihren viewController schließen können. Ich mache etwas Arbeit und löse dann einen Abwicklungssegment aus und es funktioniert perfekt.

Was nicht ideal ist, ist, dass diese Schaltfläche nicht den Pfeil <erhält und den vorherigen VCs-Titel nicht weitergibt, aber ich denke, dies kann verwaltet werden. Für meine Zwecke habe ich die neue Schaltfläche "Zurück" als "Fertig" festgelegt, damit der Zweck klar ist.

Sie haben auch zwei Zurück-Schaltflächen im IB-Navigator, die Sie jedoch aus Gründen der Übersichtlichkeit leicht beschriften können.

Schnell

override func viewWillDisappear(animated: Bool) {
    let viewControllers = self.navigationController?.viewControllers!
    if indexOfArray(viewControllers!, searchObject: self) == nil {
        // do something
    }
    super.viewWillDisappear(animated)
}

func indexOfArray(array:[AnyObject], searchObject: AnyObject)-> Int? {
    for (index, value) in enumerate(array) {
        if value as UIViewController == searchObject as UIViewController {
            return index
        }
    }
    return nil
}

Dieser Ansatz hat bei mir funktioniert (aber die Schaltfläche "Zurück" hat nicht das Zeichen "<"):

- (void)viewDidLoad
{
    [super viewDidLoad];

    UIBarButtonItem* backNavButton = [[UIBarButtonItem alloc] initWithTitle:@"Back"
                                                                      style:UIBarButtonItemStyleBordered
                                                                     target:self
                                                                     action:@selector(backButtonClicked)];
    self.navigationItem.leftBarButtonItem = backNavButton;
}

-(void)backButtonClicked
{
    // Do something...
    AppDelegate* delegate = (AppDelegate*)[[UIApplication sharedApplication] delegate];
    [delegate.navController popViewControllerAnimated:YES];
}

Schnelle Version von @ onegrays Antwort

protocol RequestsNavigationPopVerification {
    var confirmationTitle: String { get }
    var confirmationMessage: String { get }
}

extension RequestsNavigationPopVerification where Self: UIViewController {
    var confirmationTitle: String {
        return "Go back?"
    }

    var confirmationMessage: String {
        return "Are you sure?"
    }
}

final class NavigationController: UINavigationController {

    func navigationBar(navigationBar: UINavigationBar, shouldPopItem item: UINavigationItem) -> Bool {

        guard let requestsPopConfirm = topViewController as? RequestsNavigationPopVerification else {
            popViewControllerAnimated(true)
            return true
        }

        let alertController = UIAlertController(title: requestsPopConfirm.confirmationTitle, message: requestsPopConfirm.confirmationMessage, preferredStyle: .Alert)

        alertController.addAction(UIAlertAction(title: "Cancel", style: .Cancel) { _ in
            dispatch_async(dispatch_get_main_queue(), {
                let dimmed = navigationBar.subviews.flatMap { $0.alpha < 1 ? $0 : nil }
                UIView.animateWithDuration(0.25) {
                    dimmed.forEach { $0.alpha = 1 }
                }
            })
            return
        })

        alertController.addAction(UIAlertAction(title: "Go back", style: .Default) { _ in
            dispatch_async(dispatch_get_main_queue(), {
                self.popViewControllerAnimated(true)
            })
        })

        presentViewController(alertController, animated: true, completion: nil)

        return false
    }
}

Passen Sie sich jetzt in jedem Controller einfach an RequestsNavigationPopVerificationund dieses Verhalten wird standardmäßig übernommen.

Verwenden isMovingFromParentViewController

override func viewWillDisappear(animated: Bool) {
    super.viewWillDisappear(true)

    if self.isMovingFromParentViewController {
        // current viewController is removed from parent
        // do some work
    }
}

Die Antwort von @William ist jedoch richtig. Wenn der Benutzer eine Swipe-to-Go-Back-Geste startet, wird die viewWillDisappearMethode aufgerufen und befindet selfsich nicht im Navigationsstapel ( dh self.navigationController.viewControllersnicht enthalten self), selbst wenn der Swipe ausgeführt wird ist nicht abgeschlossen und der Ansichts-Controller ist nicht tatsächlich geöffnet. Die Lösung wäre also:

1. Deaktivieren Sie die Wisch-zu-Zurück-Geste in viewDidAppearund erlauben Sie nur die Verwendung der Zurück-Taste, indem Sie Folgendes verwenden:

   if ([self.navigationController respondsToSelector:@selector(interactivePopGestureRecognizer)])
   {
       self.navigationController.interactivePopGestureRecognizer.enabled = NO;
   }

2. Oder verwenden Sie viewDidDisappearstattdessen einfach wie folgt:

   - (void)viewDidDisappear:(BOOL)animated
   {
       [super viewDidDisappear:animated];
       if (![self.navigationController.viewControllers containsObject:self])
       {
           // back button was pressed or the the swipe-to-go-back gesture was
           // completed. We know this is true because self is no longer
           // in the navigation stack.
       }
   }

Die Lösung, die ich bisher gefunden habe, ist nicht sehr schön, aber sie funktioniert für mich. Mit dieser Antwort überprüfe ich auch, ob ich programmgesteuert auftauche oder nicht:

- (void)viewWillDisappear:(BOOL)animated {
  [super viewWillDisappear:animated];

  if ((self.isMovingFromParentViewController || self.isBeingDismissed)
      && !self.isPoppingProgrammatically) {
    // Do your stuff here
  }
}

Sie müssen diese Eigenschaft zu Ihrem Controller hinzufügen und auf YES setzen, bevor Sie programmgesteuert einspringen:

self.isPoppingProgrammatically = YES;
[self.navigationController popViewControllerAnimated:YES];

Neue Möglichkeit gefunden:

Ziel c

- (void)didMoveToParentViewController:(UIViewController *)parent{
    if (parent == NULL) {
        NSLog(@"Back Pressed");
    }
}

Schnell

override func didMoveToParentViewController(parent: UIViewController?) {
    if parent == nil {
        println("Back Pressed")
    }
}