# Crear un TabBar y un Navigation Controller por código en UIKit

By Tarik Pinarci (https://tarikpinarci.com). Published 2023-05-11. Canonical: https://tarikpinarci.com/es/blog/creating-tabbar-and-navigation-controller-programmatically-in-uikit

Siempre me he inclinado por un enfoque programático al desarrollar apps móviles de iOS con UIKit. Aunque los storyboards pueden parecer cómodos al principio, suelen hacerme sentir más diseñador que programador. Además, en cuanto a escalabilidad y facilidad de gestión, el enfoque programático siempre me ha parecido superior.

En este artículo explicaré el proceso de crear un tab bar controller combinado con un navigation controller usando UIKit.

### Configurar SceneDelegate

El primer paso para adoptar un enfoque programático es modificar el código raíz de nuestra aplicación. Yo lo llamo "raíz" y me recuerda a App.js o index.js en React/React Native. Es el punto de entrada de nuestra aplicación o escena. En iOS, encontramos una función scene dentro de la clase SceneDelegate, que usaremos únicamente para configurar nuestra aplicación para el desarrollo programático.

A continuación está la estructura por defecto de la clase SceneDelegate:

```swift
    import UIKit

    class SceneDelegate: UIResponder, UIWindowSceneDelegate {

      var window: UIWindow?


      func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
        // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
        // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
        guard let _ = (scene as? UIWindowScene) else { return }
      }

      func sceneDidDisconnect(_ scene: UIScene) {
        // Called as the scene is being released by the system.
        // This occurs shortly after the scene enters the background, or when its session is discarded.
        // Release any resources associated with this scene that can be re-created the next time the scene connects.
        // The scene may re-connect later, as its session was not necessarily discarded (see `application:didDiscardSceneSessions` instead).
      }

      func sceneDidBecomeActive(_ scene: UIScene) {
        // Called when the scene has moved from an inactive state to an active state.
        // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
      }

      func sceneWillResignActive(_ scene: UIScene) {
        // Called when the scene will move from an active state to an inactive state.
        // This may occur due to temporary interruptions (ex. an incoming phone call).
      }

      func sceneWillEnterForeground(_ scene: UIScene) {
        // Called as the scene transitions from the background to the foreground.
        // Use this method to undo the changes made on entering the background.
      }

      func sceneDidEnterBackground(_ scene: UIScene) {
        // Called as the scene transitions from the foreground to the background.
        // Use this method to save data, release shared resources, and store enough scene-specific state information
        // to restore the scene back to its current state.
      }
    }
```

Solo vamos a actualizar la siguiente función:

```swift
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
    // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
    // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
    guard let _ = (scene as? UIWindowScene) else { return }
  }
```

### Actualizar la función scene en SceneDelegate

En el siguiente fragmento de código, obtenemos de forma segura el windowScene usando la sentencia guard. Después, asignamos ese windowScene a la propiedad window, definida dentro de la clase SceneDelegate. Por último, invocamos el método makeKeyAndVisible para que esa ventana sea la ventana principal.

```swift
var window: UIWindow?

func scene(\_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
guard let windowScene = (scene as? UIWindowScene) else { return }
window?.windowScene = windowScene
window?.makeKeyAndVisible()
}
```

A continuación, centrémonos en crear el tab bar controller. Este controller gestionará los view controllers de cada pestaña de nuestra app. **_Por ejemplo, si tenemos dos pestañas, necesitaremos dos navigation controllers separados._** Pero ¿por qué elegimos navigation controllers? Pues porque queremos tener nuestro propio navigation controller dentro de cada pestaña. Tomemos como ejemplo la pestaña "Profile". La pantalla de perfil será la vista principal de esa pestaña, pero puede que tengamos vistas adicionales dentro de la pestaña entre las que queramos navegar. Por eso usamos navigation controllers para cada elemento de pestaña. Proporcionan la funcionalidad necesaria para navegar con fluidez entre distintos view controllers dentro de una pestaña.

¡Vamos a programarlo!

```swift
 func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    guard let windowScene = (scene as? UIWindowScene) else { return }
    window?.windowScene = windowScene
    window?.makeKeyAndVisible()

    let tabbar = UITabBarController()

    let firstVC = UINavigationController(rootViewController: ViewController())
    let secondVC = UINavigationController(rootViewController: SecondViewController())


    firstVC.tabBarItem = UITabBarItem(title: "Home", image: UIImage(systemName: "house"),selectedImage: UIImage(systemName: "house.fill"))

    secondVC.tabBarItem = UITabBarItem(title: "Profile", image: UIImage(systemName: "person"),selectedImage: UIImage(systemName: "person.fill"))

    tabbar.viewControllers = [firstVC, secondVC]

    window?.rootViewController = tabbar

  }
```

Después de inicializar nuestro tab bar controller, creamos dos navigation controllers, que corresponden a los dos elementos de pestaña de nuestra app. El primer view controller es el que viene por defecto, mientras que el segundo, llamado SecondViewController, lo veremos en la siguiente sección. SecondViewController es un view controller normal, similar al que viene por defecto.

Para configurar los elementos de pestaña, asignamos la propiedad tabItem de cada navigation controller usando UITabBarItem.

Por último, asignamos los view controllers creados a la propiedad viewControllers del tab bar controller.

Y el paso más importante es establecer nuestro tab bar controller como rootViewController de la ventana. Así nos aseguramos de que la barra de pestañas, junto con los navigation controllers de cada elemento de pestaña, quede en lo más alto de la jerarquía de nuestra app.

### Los view controllers en acción

Echemos un vistazo a nuestra clase ViewController:

```swift
class ViewController: UIViewController {

    override func viewDidLoad() {
      super.viewDidLoad()
      setupUI()
    }

    func setupUI(){
      view.backgroundColor = .white

      let homeLabel: UILabel = {
        let label = UILabel()
        label.text = "This is home screen"
        label.translatesAutoresizingMaskIntoConstraints = false
        return label
      }()

      let homeButton: UIButton = {
        let button = UIButton()
        button.setTitle("Go to profile", for: .normal)
        button.setTitleColor(.white, for: .normal)
        button.backgroundColor = .systemOrange
        button.translatesAutoresizingMaskIntoConstraints = false
        button.addTarget(self, action: #selector(goToProfile), for: .touchUpInside)
        return button
      }()

      view.addSubview(homeButton)
      view.addSubview(homeLabel)


      NSLayoutConstraint.activate([
        homeButton.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),
        homeButton.widthAnchor.constraint(equalTo: view.widthAnchor),
        homeButton.heightAnchor.constraint(equalToConstant: 72),
        homeLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor),
        homeLabel.centerYAnchor.constraint(equalTo: view.centerYAnchor)
      ])

    }

    @objc func goToProfile(){
      tabBarController?.selectedIndex = 1
    }

}
```

Y SecondViewController (_ya lo sé, el nombre no es muy afortunado…_)

![“SecondViewController”](https://cdn-images-1.medium.com/max/2000/1*38H_rYXGqsbZNlvJXlyWpg.gif)

```swift
class SecondViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
}

    func setupUI(){
      view.backgroundColor = .white

      let profileLabel: UILabel = {
        let label = UILabel()
        label.translatesAutoresizingMaskIntoConstraints = false
        label.text = "This is profile screen"
        return label
      }()

      let profileButton: UIButton = {
        let button = UIButton()
        button.setTitle("Go to home", for: .normal)
        button.setTitleColor(.white, for: .normal)
        button.backgroundColor = .systemOrange
        button.translatesAutoresizingMaskIntoConstraints = false
        button.addTarget(self, action: #selector(goToHome), for: .touchUpInside)
        return button
      }()

      view.addSubview(profileButton)
      view.addSubview(profileLabel)

      NSLayoutConstraint.activate([
        homeButton.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),
        homeButton.widthAnchor.constraint(equalTo: view.widthAnchor),
        homeButton.heightAnchor.constraint(equalToConstant: 72),
        homeLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor),
        homeLabel.centerYAnchor.constraint(equalTo: view.centerYAnchor)
      ])

    }

    @objc func goToHome(){
      tabBarController?.selectedIndex = 0
    }

}
```

> Obviamente, el código es bastante repetitivo. Pero podemos pasarlo por alto para el propósito de este artículo.

Estos dos view controllers son prácticamente idénticos, salvo por sus títulos y las acciones de sus botones. Ambos renderizan principalmente una etiqueta en el centro de la pantalla que indica el nombre de la pantalla actual. Además, tienen un botón en la parte inferior de la pantalla que permite navegar entre los elementos de pestaña. Esa es, en resumen, la funcionalidad principal de estos view controllers.

### Resultado final

¡Ya tenemos una app totalmente programática que usa un tab bar y un navigation controller, sin ningún storyboard!

![Feo, sí, pero funcional](https://cdn-images-1.medium.com/max/2000/1*Mh9-aPrme1BRh4QRjRhkVw.gif)

### Conclusión

En conclusión, adoptar un enfoque programático da más control sobre el diseño y la escalabilidad de la app, y permite a los desarrolladores centrarse en la programación en lugar de depender únicamente de los storyboards. Especialmente por los problemas con IBAction/IBOutlet**. **Un problema concreto que aparece al refactorizar código con variables IBOutlet e IBAction es la necesidad de restablecer las conexiones después de hacer cambios. En mi experiencia, tras unos días trabajando en el código, me encontré con cierres inesperados de la app sin ninguna explicación clara. Al investigar más, descubrí que la causa de esos cierres eran los nombres de variables IBOutlet e IBAction que había renombrado. Cada vez que ocurría, tenía que volver a conectar manualmente las variables afectadas para restaurar su funcionamiento. Puede ser un proceso lento y frustrante que interrumpe el flujo de desarrollo.

¡Gracias por leer!

```

```

