Understanding UIViewController Initializers in Swift

UIViewController is essential for managing views in iOS applications, and it offers multiple initializers to handle different creation scenarios. Each initializer serves a unique purpose, providing flexibility for initializing view controllers directly in code or loading them from Interface Builder files, such as storyboards or nibs. In this article, we’ll explore these initializers, how they interact with Swift’s initialization rules, and why UIViewController retains unique initializer behaviour.

Initializers in UIViewController

Let’s explore each initializer available in UIViewController, along with its examples to illustrate how and when you’d use it.

1. init()

The init() method is a parameterless initializer that allows you to create an instance of UIViewController without specifying any arguments. While it may seem like a “default initializer” in Swift, this init() is available due to Objective-C compatibility rather than being auto-generated by Swift.

For instance, if you’re creating a basic view controller entirely programmatically, such as a simple settings screen that doesn’t require layout setup from a nib or storyboard, init() works perfectly:

// Instantiate the view controller
let settingsViewController = SettingsViewController()

Here, init() provides a straightforward way to create a view controller when there’s no need for additional configuration. This initializer is especially helpful for simple, programmatically created view controllers where the layout and configuration are handled in code.

2. required init?(coder: NSCoder)

The init?(coder: NSCoder) initializer is a failable initializer and it’s used when creating a view controller from a storyboard or nib file. When a view controller is loaded from an encoded representation, such as a storyboard, this initializer decodes the view controller’s properties and initializes it to restore its previous state.

This initializer is commonly used implicitly. For example, when you instantiate a view controller from a storyboard, init?(coder:) is called automatically:

// Loading the view controller from a storyboard
let storyboard = UIStoryboard(name: "Main", bundle: nil)
if let profileViewController = storyboard.instantiateViewController(withIdentifier: "ProfileViewController") as? ProfileViewController {
    // The `init?(coder:)` initializer is called internally
    // You can now present or push `profileViewController
}

In this scenario, init?(coder:) enables the view controller to be loaded and restored with any properties set in the storyboard, such as outlets and layout configurations. This initializer is essential when using Interface Builder to design complex view layouts.

3. init(nibName: String?, bundle: Bundle?)

The init(nibName: String?, bundle: Bundle?) initializer allows you to create a view controller from a specific nib file. It’s particularly useful in projects that use nibs for defining view controller layouts. If the nib file is in the main bundle, you can pass nil for the bundle argument.

For example, if you have a custom view controller defined in a nib file named “CustomViewController”, you can initialize it like this:

// Instantiate the view controller from a nib file
let customViewController = CustomViewController(nibName: "CustomViewController", bundle: nil)

This initializer is ideal for modular projects where you might store individual screens in separate nib files rather than a single storyboard. By specifying the nib, you have more control over the loading process and can reuse the view controller layout across different parts of the app.

Why Both Default and Custom Initializers Exist in UIViewController ?

UIViewController is unique because it has both a parameterless init() initializer and custom initializers like init?(coder:) and init(nibName:bundle:). Normally, in Swift, custom initializers prevent the compiler from automatically providing a default initializer, but UIViewController is an Objective-C-based class, which influences its initializer behavior:

1. Objective-C Compatibility: UIKit was originally written in Objective-C, where parameterless initializers are common. UIViewController retains this behavior in Swift for backward compatibility.
2. Flexible Creation Patterns: By providing both init() and custom initializers, UIViewController enables developers to create instances in different ways, depending on whether the view controller is programmatically created, storyboard-based, or loaded from a nib file.

This unique behaviour demonstrates how UIKit preserves compatibility with Objective-C while supporting Swift’s initialization syntax.

Conclusion

UIViewController initializers bridge the gap between Swift’s initializer rules and Objective-C’s design principles, offering options like init(), init?(coder:), and init(nibName:bundle:) to create instances in code, from storyboards, or from nib files. By understanding these initializers, you’ll have the flexibility to choose the right method for each scenario, ensuring a seamless experience whether you’re building interfaces in code or using Interface Builder.