What is the difference between the first and second example?

What is the target responsible for?

In which case is the method called when the button is clicked?

TL; DR

When a button is clicked, our method is called in both cases.

Only in the first example, UIKit will try to call the method in the assigned target (for us this is ViewController ). It will crash if this method does not exist.

In the second example, the iOS Responder Chain is used, UIKit will look for the nearest UIResponder -a which has this method. There will be no crash if our method is not found.

UIViewController, UIView, UIApplication inherit from UIResponder .

iOS Responder Chain and what's under the hood

The UIKit iOS Responder Chain process is handled by UIKit , which dynamically works with a linked list of UIResponder . This UIKit list UIKit created from the first responder (the first UIResponder that registered the event, we have UIButton(UIView) and its subviews .

UIKit goes through the list of UIResponder and checks with canPerformAction for our function.

 open func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool 

If the selected UIResponder cannot work with a specific method,
UIKit recursively sends actions to the next UIResponder in the list using the target method which returns the next UIResponder .

 open func target(forAction action: Selector, withSender sender: Any?) -> Any? 

This process is repeated until one of the UIResponder can work with our method or the array ends and the system ignores this event.

In the second example, clicks were processed by the UIViewController , but UIKit first sent a request to the UIView since it was the first responder. He did not have the required method, so UIKit redirected actions to the next UIResponder in a linked list who was the UIViewController that had the desired method.

In most cases, the iOS Responder Chain is a simple array of subviews , but its order can be changed. You can make UIResponder (becomeFirstResponder) become
first UIResponder and return it to the old position using resignFirstResponder . This is often used with a UITextField to show the keyboard that will be called only when the UITextField is the first responder .

iOS Responder Chain and UIEvent

The Responder Chain is also involved in touching the screen, movements, clicks. When the system detects any events (touch, motion, remote-control, press), a UIEvent is created under the hood and sent using the UIApplication.shared.sendEvent() method to UIWindow . After receiving the event, UIWindow determines using the hitTest:withEvent to which UIResponder this event belongs and assigns it the first responder . Next is the work with a linked list of UIResponder described above.

To work with system UIEvent , subclasses of UIResponder (UIViewController, UIView, UIApplication) can override these methods:

 open func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) open func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) open func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) open func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) open func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) open func pressesChanged(_ presses: Set<UIPress>, with event: UIPressesEvent?) open func pressesEnded(_ presses: Set<UIPress>, with event: UIPressesEvent?) open func pressesCancelled(_ presses: Set<UIPress>, with event: UIPressesEvent?) open func motionBegan(_ motion: UIEvent.EventSubtype, with event: UIEvent?) open func motionEnded(_ motion: UIEvent.EventSubtype, with event: UIEvent?) open func motionCancelled(_ motion: UIEvent.EventSubtype, with event: UIEvent?) open func remoteControlReceived(with event: UIEvent?) 

Despite the fact that the ability to inherit and call sendEvent manually is present, UIResponder not intended for this. This can create a lot of problems with the work of custom events, which can lead to incomprehensible actions caused by an accidental first responeder that can respond to your event.

Why it is useful, where to use

Despite the fact that the iOS Responder Chain fully controlled by UIKit , it can be used to solve the problem of delegation / communication. UIResponder action is similar to the one-time NotificationCenter.default.post .

Let's take an example, we have a UIViewController , which is deep in the UINavigationController stack and we need to tell it what happened when a button was clicked on another screen. You can use the delagate pattern or NotificationCenter.default.post , but a fairly simple option is to use the iOS Responder Chain .

 button.addTarget(nil, action: #selector(RootVC.doSomething), for: .touchUpInside) 

When pressed, the method in the UIViewController will be called. #selector can take the following parameters:

 func doSomething() func doSomething(sender: Any?) func doSomething(sender: Any?, event: UIEvent?) 

sender is the object that sent the event - UIButton, UITextField, and so on.

Additional Resources for Learning [eng]:

Good description of UIEvent, UIResponder and a couple of advanced examples (patern coordinator)
Read more about ios responder chain
Practical example of a responder chain
Off dock on iOS responder chain
Off Dock by UIResponder