Preparación para entrevistas iOS

Preguntas de entrevista de iOS

20 preguntas frecuentes de entrevista sobre iOS. El desarrollo iOS es un área muy demandada centrada en crear apps con Swift, SwiftUI y UIKit, y resolver tareas de lifecycle, concurrencia, red, almacenamiento, rendimiento, pruebas y publicación en App Store. Las preguntas cubren distintos niveles, y puedes practicar respondiéndolas en voz alta en nuestro simulador de entrevistas.

Empezar una entrevista IA de iOSNo se requiere tarjeta de crédito. 1 sesión gratuita disponible.
Práctica de entrevistas técnicas en inglésDiseñado para hablantes no nativos que desean practicar entrevistas técnicas en inglés.

Preguntas para principiantes

1¿Qué es `@Binding` en SwiftUI y en qué se diferencia de `@State`?

`@Binding` crea una conexión bidireccional con una fuente de verdad que pertenece a otra vista, como una propiedad `@State`. En lugar de almacenar directamente los datos, mantiene una referencia al estado existente y permite que una vista hija lea y escriba ese valor sin ser su propietaria. La diferencia clave es la propiedad: `@State` crea y posee la fuente de verdad y asigna su almacenamiento subyacente, mientras que `@Binding` hace referencia a una fuente de verdad externa. Cuando la vista hija modifica la vinculación, se actualiza el estado del padre, lo que hace que ambas vistas vuelvan a representarse según sea necesario.

struct ParentView: View {
    @State private var isOn: Bool = false
    
    var body: some View {
        VStack {
            Text("Switch is: \(isOn ? "ON" : "OFF")")
            // Pass binding using $ prefix
            CustomToggle(isOn: $isOn)
        }
    }
}

struct CustomToggle: View {
    @Binding var isOn: Bool
    
    var body: some View {
        Button("Toggle") {
            isOn.toggle() // Modifies parent's @State
        }
    }
}
Probar responder esta pregunta con un coach de IA

2¿Cuál es la función de un perfil de aprovisionamiento en la distribución de una aplicación de iOS?

En la distribución de una aplicación de iOS, un perfil de aprovisionamiento actúa como un paquete firmado criptográficamente que vincula los requisitos de seguridad de Apple con el binario de la aplicación y los dispositivos de destino. Su función principal es indicar al sistema operativo iOS y a App Store Connect que la aplicación está autorizada para ejecutarse bajo reglas de distribución específicas. Un perfil de aprovisionamiento agrupa varios elementos críticos: el identificador de la aplicación (Bundle Identifier), el certificado o certificados de firma autorizados que confirman quién compiló la aplicación, los permisos especiales (entitlements) y las capacidades otorgadas a la aplicación (como Push Notifications, Sign in with Apple o iCloud) y, en perfiles que no son de App Store como Development o Ad-Hoc, una lista de UDID (identificadores únicos de dispositivo) de dispositivos permitidos. En los perfiles de distribución para App Store se omiten los UDID individuales porque Apple permite la distribución a cualquier dispositivo de usuario a través de App Store.

Provisioning Profile (.mobileprovision)
├── App ID / Bundle Identifier (e.g., com.example.app)
├── Certificates (Public key / Distribution Certificate)
├── Entitlements (e.g., Push Notifications, Associated Domains)
└── Device UDIDs (Present for Development/Ad-Hoc; omitted for App Store distribution)
Probar responder esta pregunta con un coach de IA

3¿Qué significa que una app de iOS ejecute tareas en segundo plano y qué límites básicos impone el sistema a ese trabajo?

Ejecutar trabajo en segundo plano en iOS significa ejecutar código cuando la app no está activa en pantalla ni visible para el usuario en ese momento. Cuando un usuario sale de una app, esta pasa del estado activo en primer plano al segundo plano, y poco después a un estado suspendido donde su ejecución se pausa, aunque su memoria permanece en la RAM (memoria de acceso aleatorio). Para preservar la duración de la batería, la capacidad de respuesta del sistema y los recursos del dispositivo, iOS controla estrictamente la ejecución en segundo plano. El sistema limita cuánto tiempo puede ejecutar código una app una vez enviada a segundo plano (por defecto, solo un breve período controlado por el sistema; una aserción finita de tarea en segundo plano o una API (interfaz de programación de aplicaciones) de segundo plano adecuada pueden conceder ejecución adicional, sin garantizar una duración fija), limita la prioridad de la CPU (unidad central de procesamiento) y de la red, y puede terminar apps suspendidas si el dispositivo experimenta presión de memoria.

import UIKit

NotificationCenter.default.addObserver(
    forName: UIApplication.didEnterBackgroundNotification,
    object: nil,
    queue: .main
) { _ in
    print("App entered background. Code execution will pause soon unless extended.")
}
Probar responder esta pregunta con un coach de IA

4¿Qué es un publisher en Combine y en qué se diferencia de un subscriber en un flujo de datos típico de iOS?

En Combine, un Publisher emite un flujo de valores a lo largo del tiempo y puede finalizar con un evento de finalización (ya sea completándose con éxito o fallando con un error). Declara dos tipos asociados: `Output` (el tipo de datos que produce) y `Failure` (el tipo de error que puede emitir). Un Subscriber recibe valores y eventos del ciclo de vida de un publisher. En un flujo de datos típico de iOS, los publishers actúan como la fuente o los productores de eventos asíncronos (como respuestas de red, notificaciones o entradas del usuario), mientras que los subscribers actúan como los consumidores que reaccionan a los valores emitidos, gestionan errores y responden a la finalización (como actualizar el estado de la interfaz de usuario o escribir en una base de datos). El subscriber se suscribe a un publisher, recibe un token de suscripción y expresa cuántos elementos está dispuesto a recibir.

import Combine

// Publisher: emits a sequence of integers
let numberPublisher = [1, 2, 3].publisher

// Subscriber: consumes the emitted integers
let cancellable = numberPublisher.sink(
    receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Finished")
        case .failure(let error):
            print("Error: \(error)")
        }
    },
    receiveValue: { value in
        print("Received: \(value)")
    }
)
Probar responder esta pregunta con un coach de IA

5¿Qué significa async/await en Swift y cómo se utiliza para llamar a una API (interfaz de programación de aplicaciones) asíncrona desde una aplicación de iOS?

`async/await` es la sintaxis nativa de Swift para escribir código asíncrono de manera lineal, legible y secuencial en lugar de usar cierres anidados y manejadores de finalización. Marcar una función con `async` le indica al compilador que la función puede suspender su ejecución mientras espera a que finalice un trabajo de larga duración (como solicitudes de red o E/S de archivos). La palabra clave `await` indica un punto de suspensión: la ejecución de la función actual se pausa, liberando el hilo subyacente para realizar otro trabajo, y se reanuda una vez que el resultado esperado o el error está listo. Para llamar a una API asíncrona en una aplicación de iOS, se invoca el método `async` precedido por `await` (y `try await` si la función arroja errores) desde un contexto asíncrono, como dentro de otra función `async` o un bloque `Task`.

func fetchUserData(from url: URL) async throws -> User {
    let (data, response) = try await URLSession.shared.data(from: url)
    
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }
    
    return try JSONDecoder().decode(User.self, from: data)
}
Probar responder esta pregunta con un coach de IA

6¿Cuándo usarías UserDefaults en una aplicación de iOS y qué tipo de datos no deberían almacenarse allí?

`UserDefaults` está diseñado para almacenar preferencias de usuario, configuraciones e indicadores pequeños y ligeros entre inicios de la aplicación (por ejemplo, preferencias de tema, nivel de volumen o un indicador booleano `hasSeenOnboarding`). Admite tipos de lista de propiedades (plist) como `String`, `Int`, `Double`, `Bool`, `Date`, `Data`, `Array` y `Dictionary`. NO se debe almacenar: 1. Información confidencial o sensible (como contraseñas de usuario, claves privadas o tokens de autenticación), ya que `UserDefaults` almacena los datos sin cifrar en un archivo plist de texto plano. 2. Conjuntos de datos grandes, documentos o archivos multimedia (como imágenes, audio o grandes cargas de datos JSON), ya que el archivo plist completo se carga en memoria al acceder a él, lo que genera una alta sobrecarga de memoria y ralentiza el inicio de la aplicación.

// Saving simple preference values
UserDefaults.standard.set(true, forKey: "hasCompletedOnboarding")
UserDefaults.standard.set("dark", forKey: "preferredTheme")

// Reading values back
let hasCompletedOnboarding = UserDefaults.standard.bool(forKey: "hasCompletedOnboarding")
let theme = UserDefaults.standard.string(forKey: "preferredTheme") ?? "system"
Probar responder esta pregunta con un coach de IA

7¿Qué es ARC (recuento automático de referencias) en Swift y cómo gestiona el ciclo de vida de las instancias de clases en una aplicación iOS?

ARC (recuento automático de referencias) es el mecanismo de gestión de memoria en tiempo de compilación de Swift para rastrear y administrar el ciclo de vida de las instancias de clases (tipos por referencia). Cada vez que se crea una nueva instancia de una clase y se asigna a una referencia fuerte, ARC lleva un recuento interno de referencias para esa instancia. Mientras exista al menos una referencia fuerte hacia una instancia, ARC la mantiene en memoria. Cuando se eliminan todas las referencias fuertes y el recuento de referencias llega a cero, ARC desasigna inmediatamente la instancia para liberar memoria, invocando automáticamente el método `deinit` de la instancia justo antes de la desasignación. A diferencia de la recolección de basura en tiempo de ejecución de entornos como Java o .NET, ARC no ejecuta ciclos de barrido periódicos; el compilador de Swift inserta las llamadas correspondientes de retención y liberación directamente en el binario durante el tiempo de compilación.

class User {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) initialized")
    }
    deinit {
        print("\(name) deallocated")
    }
}

var ref1: User? = User(name: "Alice") // count = 1
var ref2: User? = ref1               // count = 2

ref1 = nil                           // count = 1
ref2 = nil                           // count = 0 -> deinit called
Probar responder esta pregunta con un coach de IA

8¿Cómo se realiza una solicitud HTTP (protocolo de transferencia de hipertexto) GET simple con URLSession en una aplicación para iOS?

Para realizar una solicitud HTTP GET simple en una aplicación para iOS, se crea un objeto URL y se pasa a una instancia de URLSession, como URLSession.shared. La solicitud se puede ejecutar utilizando un manejador de finalización de tarea de datos (URLSession.shared.dataTask(with: url) { data, response, error in ... }) o mediante la concurrencia moderna de Swift (let (data, response) = try await URLSession.shared.data(from: url)). Cuando se utiliza el enfoque tradicional de tarea de datos, se debe llamar a .resume() en la tarea para iniciarla, gestionar cualquier error de transporte, inspeccionar el código de estado de HTTPURLResponse y asegurarse de que cualquier actualización de la interfaz de usuario se despache en el hilo principal.

guard let url = URL(string: "https://api.example.com/items") else { return }

let task = URLSession.shared.dataTask(with: url) { data, response, error in
    if let error = error {
        print("Network error: \(error.localizedDescription)")
        return
    }
    
    guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
        print("Server error or invalid status code")
        return
    }
    
    if let data = data {
        DispatchQueue.main.async {
            // Update UI on main thread
        }
    }
}
task.resume()
Probar responder esta pregunta con un coach de IA

9¿Qué es Instruments en Xcode y cómo se utilizaría para investigar un problema de rendimiento simple en una aplicación para iOS?

Instruments es la herramienta de análisis y creación de perfiles de rendimiento de Apple integrada en Xcode. Permite a los desarrolladores monitorizar el comportamiento en tiempo de ejecución, el uso de CPU, las asignaciones de memoria, las fugas de memoria y el rendimiento del renderizado de la interfaz de usuario. Para investigar un problema de rendimiento simple (como tirones en la interfaz o un uso elevado de CPU), se inicia Instruments desde Xcode (a través de Product -> Profile), se elige una plantilla adecuada (como Time Profiler para cuellos de botella de CPU o Allocations/Leaks para problemas de memoria) y se graba una traza mientras se reproduce el flujo de usuario problemático en un dispositivo. Tras la grabación, se analiza el árbol de llamadas y las trazas de pila con mayor coste para identificar con precisión los métodos exactos que causan retrasos o un consumo excesivo de recursos, lo que permite medir y localizar el cuello de botella antes de realizar cambios en el código.

1. In Xcode, select Product -> Profile (Builds with Release optimizations).
2. Select the 'Time Profiler' template.
3. Click Record and perform the sluggish action in the app.
4. Stop recording.
5. Inspect the Call Tree tab:
   - Enable 'Separate by Thread' and 'Hide System Libraries'.
   - Trace the heaviest call stack on the Main Thread to identify the blocking function.
Probar responder esta pregunta con un coach de IA

10¿Qué es APNs (servicio de notificaciones push de Apple) y qué rol desempeña en la entrega de notificaciones push a una aplicación de iOS?

APNs (servicio de notificaciones push de Apple) es el servicio intermediario en la nube de Apple que enruta de forma segura notificaciones push desde los servidores de backend (servidores de proveedor) hacia los dispositivos Apple. Dado que los dispositivos móviles no pueden mantener conexiones socket abiertas y continuas con el backend de cada aplicación individual sin agotar la batería y consumir un ancho de banda de red excesivo, Apple mantiene una única conexión persistente y de bajo consumo entre cada dispositivo y APNs. Cuando tu aplicación se registra para recibir notificaciones remotas, APNs genera un token de dispositivo opaco y único que identifica esa instalación específica de la aplicación en ese dispositivo en particular. La aplicación envía este token al servidor proveedor de tu backend. Cuando el proveedor desea notificar al usuario, construye una carga útil y la envía junto con el token de dispositivo a APNs a través de HTTP/2. Posteriormente, APNs localiza la conexión activa para ese dispositivo y entrega la carga útil de la notificación push directamente a iOS, que muestra la alerta o activa la aplicación según esté configurado.

[Provider Server] ---> (HTTP/2 Request + Device Token + Payload) ---> [APNs]
                                                                           |
                                                               (Persistent APNs Connection)
                                                                           v
                                                                    [iOS Device / App]
Probar responder esta pregunta con un coach de IA

Preguntas intermedias

11¿Cómo incorporarías noticias nuevas al principio de un UITableView sin repetir identificadores?

Crea la lista en el orden recibido y añade entradas previas con IDs aún no vistos. Actualiza en Main Actor y termina el control de refresco tanto en éxito como en fallo.

Probar responder esta pregunta con un coach de IA

12¿Qué distingue a un actor de Swift de una clase ordinaria cuando varias tareas acceden a datos mutables?

Compartir una clase no protege automáticamente sus propiedades. Un actor establece aislamiento y su ejecutor coordina el acceso al estado aislado. Cruzar esa frontera suele requerir una operación asíncrona, lo que evita carreras sin bloquear manualmente cada propiedad. El actor no recibe un hilo propio ni convierte todo método async en una transacción. En un await puede entrar otro trabajo y cambiar el estado. Revalido supuestos al volver, agrupo cambios de invariantes en secciones síncronas y uso versiones o transiciones si atravieso una suspensión. Los miembros nonisolated y datos transferidos siguen sus propias reglas. El orden lógico de la aplicación sigue requiriendo diseño.

Probar responder esta pregunta con un coach de IA

13¿Cómo probarías carga, éxito y cancelación de un modelo de vista iOS sin llamar a la API real?

Inyecto un doble de un protocolo de API pequeño cuya respuesta async controla la prueba. Inicio la carga, verifico el estado, completo con datos o error y compruebo el resultado y los datos preservados. En cancelación verifico que la tarea se cancela, que el indicador se limpia según contrato y que no se muestra un error ordinario salvo que se haya decidido así. Una finalización tardía demuestra que la respuesta obsoleta no pisa una selección nueva. Respeto el aislamiento del actor y uso sincronización explícita o reloj controlable en vez de pausas. Cubro cargas repetidas, liberación o salida de pantalla. Verifico comportamiento observable sin red ni credenciales.

Probar responder esta pregunta con un coach de IA

14¿Cómo construirías una cadena de Combine para un campo de texto de búsqueda que espere una pausa en la entrada mediante debounce, ignore duplicados, realice una solicitud de red y actualice la interfaz de usuario de forma segura?

Para construir una cadena de búsqueda seguro en Combine: 1. **Debounce y deduplicación:** Toma el publicador de la consulta de búsqueda (por ejemplo, `$queryText`), aplica `.debounce(for: .milliseconds(300), scheduler: RunLoop.main)` para esperar las pausas al escribir, y `.removeDuplicates()` para ignorar cadenas de búsqueda que no hayan cambiado. 2. **Solicitud de red y cancelación:** Mapea cada consulta a un publicador de solicitud de red y aplánalo mediante `.switchToLatest()`. Esto cancela automáticamente las solicitudes en curso cuando llega una nueva consulta de búsqueda, evitando condiciones de carrera y resultados obsoletos. 3. **Aislar errores:** Captura los errores de red dentro del publicador interno (por ejemplo, `.catch { _ in Just([]) }`) para que los fallos de red no terminen el flujo principal de texto de búsqueda. 4. **Entrega en el hilo principal:** Aplica `.receive(on: DispatchQueue.main)` antes de actualizar el estado o asignarlo a las propiedades de la interfaz de usuario.

import Combine
import Foundation

class SearchViewModel: ObservableObject {
    @Published var query: String = ""
    @Published var searchResults: [String] = []
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        $query
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .removeDuplicates()
            .map { query -> AnyPublisher<[String], Never> in
                guard !query.trimmingCharacters(in: .whitespaces).isEmpty else {
                    return Just([]).eraseToAnyPublisher()
                }
                return self.performSearch(query)
                    .catch { _ in Just([]) }
                    .eraseToAnyPublisher()
            }
            .switchToLatest()
            .receive(on: DispatchQueue.main)
            .assign(to: &$searchResults)
    }
    
    private func performSearch(_ term: String) -> AnyPublisher<[String], Error> {
        let url = URL(string: "https://api.example.com/search?q=\(term)")!
        return URLSession.shared.dataTaskPublisher(for: url)
            .map(\.data)
            .decode(type: [String].self, decoder: JSONDecoder())
            .eraseToAnyPublisher()
    }
}
Probar responder esta pregunta con un coach de IA

15¿Cómo utilizarías async/await y la cancelación de `Task` en Swift para implementar una pantalla que cargue datos de la red y evite actualizar la interfaz de usuario si el usuario navega a otra pantalla?

Implementaría la carga de datos de red como una función `async` en un servicio o modelo de vista y la ejecutaría desde una `Task` cuyo ciclo de vida esté ligado al de la pantalla. En UIKit, esto suele implicar almacenar una referencia como `var loadTask: Task<Void, Never>?` en el controlador de vista o modelo de vista, iniciarla cuando la pantalla deba cargar los datos y cancelarla en `viewWillDisappear`, `deinit` o antes de lanzar una nueva solicitud, según el ciclo de vida deseado. En SwiftUI, optaría por `.task` o `.task(id:)` siempre que sea posible, ya que SwiftUI cancela automáticamente la tarea cuando la vista desaparece o cuando el identificador cambia. Dentro de la tarea, llamaría a la API asíncrona de red mediante `try await`, gestionaría la cancelación de forma independiente a los errores reales y verificaría si la tarea fue cancelada antes de aplicar los resultados si existen múltiples `await` o pasos de procesamiento intermedios. Las mutaciones del estado de la interfaz deben ejecutarse obligatoriamente en el actor principal, ya sea marcando el modelo de vista con `@MainActor` o utilizando `await MainActor.run`. Para evitar actualizaciones obsoletas en la interfaz, cancelaría las tareas previas, evitaría el uso de tareas desconectadas o globales (`Task.detached`) para operaciones vinculadas a una pantalla y, opcionalmente, compararía un identificador de solicitud o el identificador del elemento actual antes de aplicar el resultado.

@MainActor
final class UsersViewController: UIViewController {
    private var loadTask: Task<Void, Never>?
    private let service: UserService

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

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        loadTask?.cancel()
    }

    private func loadUsers() {
        loadTask?.cancel()
        loadingView.isHidden = false

        loadTask = Task { [weak self] in
            do {
                let users = try await self?.service.fetchUsers() ?? []
                try Task.checkCancellation()

                guard let self else { return }
                self.loadingView.isHidden = true
                self.tableModel = users
                self.tableView.reloadData()
            } catch is CancellationError {
                // User navigated away or a new load replaced this one; do not update UI.
            } catch {
                guard let self else { return }
                self.loadingView.isHidden = true
                self.showError(error)
            }
        }
    }
}
Probar responder esta pregunta con un coach de IA

16¿Cómo elegirías entre UserDefaults, Keychain, archivos, SQLite y Core Data para diferentes tipos de datos de una aplicación?

La elección del mecanismo de almacenamiento de iOS adecuado depende de la sensibilidad de los datos, su tamaño, complejidad relacional, requisitos de consulta y ciclo de vida de las copias de seguridad: 1. **Keychain**: Para datos confidenciales (tokens de autenticación, contraseñas, claves de cifrado). Admite almacenamiento cifrado y controles de acceso; las plantillas biométricas permanecen gestionadas por el sistema y no se exponen a las aplicaciones. Keychain no garantiza la confidencialidad frente al código que se ejecuta con el acceso autorizado de la aplicación, y la persistencia tras una reinstalación no debe tratarse como un contrato de almacenamiento. 2. **UserDefaults**: Para preferencias e indicadores ligeros y no confidenciales (por ejemplo, `hasCompletedOnboarding`, preferencia de tema). Dado que está optimizado para preferencias pequeñas, no debe utilizarse para conjuntos de datos grandes, contenido multimedia o tokens confidenciales. 3. **Sistema de archivos (Documents / Caches / Application Support)**: Para archivos discretos y objetos binarios grandes (imágenes descargadas, audio, PDF — Portable Document Format, formato de documento portátil). `Documents` está orientado al usuario y se incluye en la copia de seguridad de iCloud; `Caches` es para contenido descartable y que se puede volver a descargar; `Application Support` es para archivos persistentes no orientados al usuario. 4. **SQLite**: Para datos estructurados y tabulares que requieren consultas indexadas rápidas, operaciones masivas o uso compartido de la base de datos entre plataformas sin la sobrecarga de un grafo de objetos. 5. **Core Data / SwiftData**: Para grafos de objetos complejos con relaciones, seguimiento de cambios, faulting, gestión de deshacer (undo) e integración directa con UIKit (`NSFetchedResultsController`) o SwiftUI (`@Query`).

- Auth tokens / API keys          -> Keychain (Hardware-backed encrypted store)
- App settings / UI flags         -> UserDefaults (Lightweight key-value, non-sensitive)
- Downloaded videos / PDFs        -> File System (Documents / Caches directory)
- 50k items with complex queries   -> SQLite / Core Data / SwiftData (Indexed, relationship-aware)
Probar responder esta pregunta con un coach de IA

17En una pantalla de UIKit en producción con funciones de retorno desde un modelo de vista, ¿cómo decidirías si capturar `self` de forma débil, sin propiedad (`unowned`) o fuerte en los cierres?

En una arquitectura UIKit donde un controlador de vista interactúa con un modelo de vista mediante funciones de retorno, la estrategia depende de la propiedad y el ciclo de vida: 1. `[weak self]` es el enfoque estándar y más seguro para cierres almacenados o que escapan, como funciones de retorno de eventos del modelo de vista o manejadores asíncronos de finalización de red o datos. Como el controlador posee el modelo de vista, capturar `self` fuertemente en un cierre almacenado por este crea un ciclo: `VC -> VM -> closure -> VC`. `[weak self]` convierte `self` en un opcional (`UIViewController?`), permitiendo liberarlo y evitando fugas. 2. `[unowned self]` presupone que `self` nunca será `nil` cuando se ejecute el cierre. Debe usarse con extrema precaución en pantallas: si una tarea o función de retorno termina después de cerrar y liberar el controlador, acceder a `unowned self` provoca un fallo fatal. Por ello, suele preferirse `[weak self]` en funciones de retorno de interfaz de UIKit en producción. 3. La captura fuerte, predeterminada sin lista de captura, es adecuada cuando el cierre no escapa, como en operaciones normales de colecciones `map` o `filter`, o cuando vive poco tiempo y no crea un ciclo de propiedad de vuelta a `self`.

final class ProfileViewController: UIViewController {
    private let viewModel: ProfileViewModel

    init(viewModel: ProfileViewModel) {
        self.viewModel = viewModel
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder: NSCoder) { fatalError() }

    override func viewDidLoad() {
        super.viewDidLoad()
        
        // VM stores the callback -> capture weak self to break retain cycle
        viewModel.onDataUpdated = { [weak self] state in
            guard let self else { return }
            self.updateUI(with: state)
        }
    }

    private func updateUI(with state: ProfileState) { /* Update views */ }
}
Probar responder esta pregunta con un coach de IA

Preguntas avanzadas

18¿Cómo introducirías SwiftUI pantalla por pantalla en una aplicación UIKit grande?

Elijo una pantalla acotada con entradas y salidas claras y la integro mediante UIHostingController conservando navegación y ciclo de vida UIKit. Mantengo lógica y repositorios independientes y un propietario explícito por estado. Para reutilizar controles o controladores UIKit empleo UIViewRepresentable o UIViewControllerRepresentable y, si procede, un coordinador para callbacks. Compruebo navegación, cierre, foco, accesibilidad, temas y versiones mínimas. Pruebo comportamiento y transiciones, comparo aspecto y rendimiento y preveo una entrada reversible si el riesgo lo exige. Repito por pantalla sin duplicar las fuentes de verdad.

Probar responder esta pregunta con un coach de IA

19Estás lanzando una aplicación iOS de alto tráfico con una migración de base de datos y un cambio en la API (interfaz de programación de aplicaciones) del servidor; ¿cómo diseñarías el plan de despliegue para minimizar el impacto en los usuarios?

Diseñar un plan de despliegue para una aplicación iOS de alto tráfico que involucra migraciones de base de datos y cambios en la API del backend requiere desacoplar el despliegue de la activación de funcionalidades, dadas las restricciones del cliente iOS (actualizaciones asíncronas por parte de los usuarios e imposibilidad de forzar retornos a versiones anteriores del binario en el cliente). 1. Compatibilidad en el backend: Implementar una estrategia de «expandir y contraer». Desplegar la API v2 junto con la API v1 para que tanto las versiones heredadas como las actualizadas del cliente funcionen en paralelo sin introducir cambios disruptivos. 2. Migración resiliente de la base de datos: Asegurar que las migraciones de esquemas locales (por ejemplo, SQLite, Core Data o SwiftData) sean idempotentes, no destructivas y gestionen con seguridad saltos entre múltiples versiones (por ejemplo, actualizar de N-3 a N) sin bloquear el hilo principal ni provocar bucles de caídas al iniciar la app. 3. Activación dinámica controlada: Publicar las nuevas funciones del cliente ocultas tras indicadores de activación de funcionalidades o configuración remota gestionada desde el servidor. Mantener el indicador de activación desactivado durante la distribución inicial. 4. Despliegue gradual y monitorización: Distribuir la aplicación mediante App Store Phased Release (un despliegue escalonado en 7 días). Monitorizar continuamente la telemetría, las tasas de fallos, las métricas de éxito en las migraciones de base de datos y las tasas de error de la API. Si se detectan anomalías, pausar el despliegue gradual en App Store Connect y desactivar los indicadores de activación sin requerir una reversión urgente del binario.

Phase 1 (Backend Expand): Deploy API v2 supporting both new and legacy payloads.
Phase 2 (Client Distribution & Migration): Release client v2.0 via App Store Phased Release (1% -> 100%). DB migrates safely on first launch. Feature flag remains OFF.
Phase 3 (Validation & Feature Enablement): Monitor crash rates & migration success. Incrementally ramp Remote Config flag (10% -> 50% -> 100%).
Phase 4 (Backend Contract): Once legacy app adoption drops below deprecation threshold, sunset API v1.
Probar responder esta pregunta con un coach de IA

20Estás diseñando una sincronización offline-first para una app de notas donde las ediciones deben sincronizarse eventualmente entre dispositivos, pero iOS puede posponer o cancelar el trabajo en segundo plano. ¿Qué arquitectura de ejecución en segundo plano elegirías?

Una arquitectura de sincronización offline-first trata a la base de datos local (como SQLite, Core Data o SwiftData) como la única fuente de la verdad inmediata para el estado de la UI (interfaz de usuario), mientras que las mutaciones se agregan a una cola persistente de bandeja de salida (outbox queue) en disco para que las ediciones no enviadas sobrevivan a la muerte del proceso. Para gestionar la ejecución en segundo plano oportunista y no determinista de iOS, el trabajo en segundo plano se estructura en múltiples niveles: 1. Vaciado de la bandeja de salida al pasar a segundo plano: iniciado mediante `UIApplication.shared.beginBackgroundTask(expirationHandler:)` para terminar mutaciones en curso o pendientes rápidas. 2. Sincronización programada de manera oportunista: registrada con `BGTaskScheduler` utilizando `BGAppRefreshTask` para sincronizaciones ligeras de metadatos/deltas y `BGProcessingTask` para operaciones de sincronización más pesadas. 3. Sincronización de recursos grandes: gestionada fuera de proceso a través de una `URLSessionConfiguration` en segundo plano utilizando subidas/descargas de archivos. 4. Sincronización activada por el servidor: despertares oportunistas mediante notificaciones push silenciosas (`content-available: 1`). Dado que las tareas en segundo plano pueden interrumpirse o reprogramarse en cualquier momento, las operaciones deben utilizar claves de idempotencia generadas por el cliente (p. ej., UUID, Universally Unique Identifier — identificadores universalmente únicos) para permitir reintentos seguros sin duplicar datos. Si se llama al `expirationHandler` de una tarea, el trabajo en curso debe cancelarse de inmediato, las operaciones no confirmadas deben marcarse nuevamente como pendientes y debe llamarse a `setTaskCompleted(success: false)`. Sincroniza también cuando la app pase a primer plano y después de ediciones locales, con un único responsable coordinado de la sincronización. El lanzamiento en segundo plano nunca está garantizado, por lo que no prometas un plazo fijo de convergencia. La consistencia eventual se persigue utilizando mecanismos de resolución de conflictos como CRDT (tipos de datos replicados libres de conflictos), vectores de versiones combinados con una política de fusión o "el último en escribir gana" (last-write-wins) con lápidas de borrado (deletion tombstones), asegurando que los deltas remotos no sobrescriban mutaciones locales no confirmadas de la bandeja de salida.

import BackgroundTasks
import Foundation

final class NoteSyncCoordinator {
    static let shared = NoteSyncCoordinator()
    private let syncTaskID = "com.notesapp.sync.refresh"

    func registerSyncTask() {
        BGTaskScheduler.shared.register(forTaskWithIdentifier: syncTaskID, using: nil) { task in
            guard let refreshTask = task as? BGAppRefreshTask else { return }
            self.handleAppRefresh(task: refreshTask)
        }
    }

    func scheduleNextSync() {
        let request = BGAppRefreshTaskRequest(identifier: syncTaskID)
        request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
        try? BGTaskScheduler.shared.submit(request)
    }

    private func handleAppRefresh(task: BGAppRefreshTask) {
        scheduleNextSync()
        let syncTask = Task {
            do {
                try await SyncEngine.shared.flushPersistentOutboxAndFetchDeltas()
                task.setTaskCompleted(success: true)
            } catch {
                task.setTaskCompleted(success: false)
            }
        }

        task.expirationHandler = {
            syncTask.cancel()
        }
    }
}
Probar responder esta pregunta con un coach de IA

Practica entrevistas de Desarrollador iOS en tu móvil

Responde en voz alta y recibe comentarios de la IA en la app para Android.

Descarga EngineerSpeak en Google Play
Escanea para descargar