Preguntas de entrevista para desarrollador iOS junior: Swift, UIKit y SwiftUI

Introducción

En una entrevista para desarrollador iOS junior, suelen comprobar si puedes explicar fundamentos de Swift, crear UI simple con UIKit o SwiftUI, consumir y decodificar datos, elegir una opción básica de persistencia y evitar errores comunes de memoria o threading. Las mejores respuestas son breves, concretas y conectadas con cómo construirías una app pequeña.

Usa esta guía para practicar las preguntas más probables en un primer filtro iOS: qué significa cada concepto, cuándo lo usarías y qué riesgo debería vigilar una persona junior.

Fundamentos de Swift (6 Preguntas)

1. ¿Cuál es la diferencia entre var y let en Swift?

Respuesta:

• var: Declara una variable mutable. Su valor se puede cambiar después de la inicialización.
• let: Declara una constante inmutable. Una vez establecida, su valor no se puede cambiar.
• Mejor práctica: Utiliza let por defecto para mayor seguridad y claridad. Solo usa var cuando sepas que el valor va a cambiar.

let name = "John"  // No se puede cambiar
var age = 25       // Se puede cambiar
age = 26           // Válido
// name = "Jane"   // Error: No se puede asignar al valor

Frecuencia: Muy Común Dificultad: Fácil

2. Explica los Optionals en Swift. ¿Qué es el Optional Binding?

Respuesta: Los Optionals representan un valor que podría ser nil (ausencia de valor).

• Declaración: Usa ? después del tipo: var name: String?
• Métodos de Desempaquetado:
  • Force Unwrapping: name! (peligroso, falla si es nil)
  • Optional Binding: Desempaqueta de forma segura usando if let o guard let
  • Nil Coalescing: name ?? "Default"
  • Optional Chaining: user?.address?.city

var email: String? = "[email protected]"

// Optional Binding
if let unwrappedEmail = email {
    print("Email: \(unwrappedEmail)")
} else {
    print("No hay email")
}

// Sentencia Guard
guard let email = email else { return }
print(email)

Frecuencia: Muy Común Dificultad: Fácil

3. ¿Cuál es la diferencia entre una class y una struct en Swift?

Respuesta:

• Class: Tipo de referencia (almacenado en el heap). Admite herencia. Se pasa por referencia.
• Struct: Tipo de valor (almacenado en la pila). No hay herencia. Se pasa por copia.
• Cuándo usar:
  • Struct: Para modelos de datos simples, cuando se desean semánticas de valor (copias independientes)
  • Class: Cuando se necesita herencia, semántica de referencia o desinicializadores

struct Point {
    var x: Int
    var y: Int
}

class Person {
    var name: String
    init(name: String) { self.name = name }
}

var p1 = Point(x: 0, y: 0)
var p2 = p1  // Se crea una copia
p2.x = 10    // p1.x sigue siendo 0

var person1 = Person(name: "John")
var person2 = person1  // Misma referencia
person2.name = "Jane"  // person1.name también es "Jane"

Frecuencia: Muy Común Dificultad: Media

4. ¿Qué son los Closures en Swift?

Respuesta: Los Closures son bloques de funcionalidad autocontenidos que se pueden pasar y usar en tu código. Son similares a las lambdas o funciones anónimas en otros lenguajes.

• Sintaxis: { (parámetros) -> TipoDeRetorno in sentencias }
• Captura de Valores: Los Closures pueden capturar y almacenar referencias a variables de su contexto circundante.
• Uso Común: Completion handlers, callbacks, operaciones de array.

// Closure simple
let greet = { (name: String) -> String in
    return "¡Hola, \(name)!"
}
print(greet("Alice"))

// Sintaxis de trailing closure
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }
print(doubled)  // [2, 4, 6, 8, 10]

Frecuencia: Muy Común Dificultad: Media

5. Explica la diferencia entre referencias weak y unowned.

Respuesta: Ambas se utilizan para prevenir ciclos de retención (fugas de memoria) en tipos de referencia.

• weak: Referencia opcional que automáticamente se convierte en nil cuando el objeto referenciado se desasigna. Úsala cuando la referencia pueda sobrevivir al objeto.
• unowned: Referencia no opcional que asume que el objeto siempre existirá. Falla si se accede a ella después de la desasignación. Úsala cuando estés seguro de que la referencia no sobrevivirá al objeto.

class Person {
    var name: String
    weak var apartment: Apartment?  // weak para prevenir el ciclo de retención
    init(name: String) { self.name = name }
}

class Apartment {
    var unit: String
    unowned let tenant: Person  // unowned - el apartamento siempre tiene un inquilino
    init(unit: String, tenant: Person) {
        self.unit = unit
        self.tenant = tenant
    }
}

Frecuencia: Común Dificultad: Media

6. ¿Qué son los Protocolos en Swift?

Respuesta: Los protocolos definen un esquema de métodos, propiedades y otros requisitos que se adaptan a una tarea o funcionalidad particular. Las clases, structs y enums pueden adoptar protocolos.

• Similar a: Interfaces en otros lenguajes
• Extensiones de Protocolo: Pueden proporcionar implementaciones predeterminadas
• Programación Orientada a Protocolos: El paradigma preferido de Swift

protocol Drawable {
    func draw()
}

struct Circle: Drawable {
    var radius: Double
    
    func draw() {
        print("Dibujando círculo con radio \(radius)")
    }
}

struct Rectangle: Drawable {
    var width: Double
    var height: Double
    
    func draw() {
        print("Dibujando rectángulo \(width)x\(height)")
    }
}

Frecuencia: Muy Común Dificultad: Fácil

Fundamentos de UIKit (5 Preguntas)

7. ¿Cuál es la diferencia entre UIView y UIViewController?

Respuesta:

• UIView: Representa un área rectangular en la pantalla. Maneja el dibujo y el manejo de eventos. Ejemplos: UILabel, UIButton, UIImageView.
• UIViewController: Gestiona una jerarquía de vistas. Maneja el ciclo de vida de la vista, las interacciones del usuario y la navegación. Contiene una vista raíz y gestiona sus subvistas.
• Relación: Un controlador de vista gestiona vistas. Un controlador de vista puede tener muchas vistas.

Frecuencia: Muy Común Dificultad: Fácil

8. Explica los métodos del ciclo de vida del Controlador de Vista.

Respuesta: Los controladores de vista tienen métodos de ciclo de vida específicos que se llaman en orden:

1. viewDidLoad(): Se llama una vez cuando la vista se carga en la memoria. Configuración que debe ocurrir una vez.
2. viewWillAppear(_:): Se llama antes de que la vista aparezca en la pantalla. Se puede llamar varias veces.
3. viewDidAppear(_:): Se llama después de que la vista aparece en la pantalla. Comienza las animaciones aquí.
4. viewWillDisappear(_:): Se llama antes de que la vista desaparezca.
5. viewDidDisappear(_:): Se llama después de que la vista desaparece. Limpia los recursos.

override func viewDidLoad() {
    super.viewDidLoad()
    // Configuración única: configurar la interfaz de usuario, cargar datos
}

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    // Actualizar datos, comenzar a escuchar notificaciones
}

Frecuencia: Muy Común Dificultad: Fácil

9. ¿Qué es Auto Layout y cómo usas las constraints?

Respuesta: Auto Layout es un sistema de diseño basado en constraints que te permite crear interfaces de usuario adaptables que funcionan en diferentes tamaños y orientaciones de pantalla.

• Constraints: Definen las relaciones entre las vistas (ancho, alto, espacio, alineación)
• Métodos:
  • Interface Builder: Editor visual en Xcode
  • Programático: API NSLayoutConstraint o NSLayoutAnchor
  • Visual Format Language: Basado en cadenas (menos común ahora)

let button = UIButton()
button.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(button)

NSLayoutConstraint.activate([
    button.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    button.centerYAnchor.constraint(equalTo: view.centerYAnchor),
    button.widthAnchor.constraint(equalToConstant: 200),
    button.heightAnchor.constraint(equalToConstant: 50)
])

Frecuencia: Muy Común Dificultad: Media

10. ¿Cuál es la diferencia entre frame y bounds?

Respuesta:

• frame: La ubicación y el tamaño de la vista en el sistema de coordenadas de su supervista. Se utiliza para posicionar la vista.
• bounds: La ubicación y el tamaño de la vista en su propio sistema de coordenadas. El origen suele ser (0, 0). Se utiliza para dibujar contenido dentro de la vista.
• Diferencia clave: frame es relativo al padre, bounds es relativo a sí mismo.

let view = UIView(frame: CGRect(x: 50, y: 100, width: 200, height: 150))
print(view.frame)   // (50, 100, 200, 150) - posición en la supervista
print(view.bounds)  // (0, 0, 200, 150) - propio sistema de coordenadas

Frecuencia: Común Dificultad: Media

11. ¿Cómo manejas la entrada del usuario desde un UITextField?

Respuesta: Existen múltiples enfoques:

• Target-Action: Agregar target para el evento .editingChanged
• Delegate: Conformar al protocolo UITextFieldDelegate
• Combine: Usar publishers (enfoque moderno)

class ViewController: UIViewController, UITextFieldDelegate {
    let textField = UITextField()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Enfoque Delegate
        textField.delegate = self
        
        // Enfoque Target-Action
        textField.addTarget(self, action: #selector(textChanged), for: .editingChanged)
    }
    
    @objc func textChanged(_ textField: UITextField) {
        print("Texto: \(textField.text ?? "")")
    }
    
    // Método Delegate
    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
        textField.resignFirstResponder()
        return true
    }
}

Frecuencia: Muy Común Dificultad: Fácil

Fundamentos de SwiftUI (4 Preguntas)

12. ¿Qué es SwiftUI y en qué se diferencia de UIKit?

Respuesta: SwiftUI es el framework declarativo de Apple para crear interfaces. Describes la UI como una función del estado, y SwiftUI actualiza la vista renderizada cuando ese estado cambia. UIKit es imperativo: creas y modificas directamente objetos como UIView, UILabel y UIViewController.

En una entrevista junior, no lo presentes como si SwiftUI sustituyera a UIKit en todos los casos. Muchas apps de producción combinan ambos. Una buena respuesta: SwiftUI es conciso para pantallas nuevas y UI basada en estado; UIKit sigue siendo importante en bases de código existentes, controles personalizados y APIs que SwiftUI no cubre por completo.

struct CounterView: View {
    @State private var count = 0

    var body: some View {
        VStack {
            Text("Count: \(count)")
            Button("Increment") {
                count += 1
            }
        }
    }
}

Frecuencia: Muy Común Dificultad: Fácil

13. Explica @State, @Binding y @ObservedObject en SwiftUI.

Respuesta: Estos wrappers indican dónde vive el estado y quién puede modificarlo.

• @State: Estado privado propiedad de una vista, normalmente para estado local de UI.
• @Binding: Conexión bidireccional con estado propiedad de una vista padre. La vista hija puede leerlo y escribirlo sin ser dueña.
• @ObservedObject: Referencia a datos observables externos. Se usa cuando otro objeto posee los datos y la vista debe refrescarse al cambiar. En código SwiftUI más nuevo también puedes ver el framework Observation y @Observable, aunque muchas entrevistas siguen preguntando por estos wrappers.

class UserData: ObservableObject {
    @Published var name = ""
}

struct ParentView: View {
    @State private var isOn = false
    @ObservedObject var userData = UserData()

    var body: some View {
        VStack {
            ChildView(isOn: $isOn)
            Text(userData.name)
        }
    }
}

struct ChildView: View {
    @Binding var isOn: Bool

    var body: some View {
        Toggle("Switch", isOn: $isOn)
    }
}

Frecuencia: Común Dificultad: Media

14. ¿Cómo se crea una lista en SwiftUI?

Respuesta: Usa la vista List para mostrar colecciones de datos desplazables.

struct ContentView: View {
    let fruits = ["Manzana", "Plátano", "Naranja", "Uva"]
    
    var body: some View {
        List(fruits, id: \.self) { fruit in
            Text(fruit)
        }
    }
}

// Con modelo personalizado
struct Task: Identifiable {
    let id = UUID()
    let title: String
}

struct TaskListView: View {
    let tasks = [
        Task(title: "Comprar comestibles"),
        Task(title: "Pasear al perro")
    ]
    
    var body: some View {
        List(tasks) { task in
            Text(task.title)
        }
    }
}

Frecuencia: Común Dificultad: Fácil

15. ¿Qué son los Modificadores de Vista en SwiftUI?

Respuesta: Los modificadores de vista son métodos que crean una nueva vista con propiedades modificadas. Son encadenables.

• Modificadores comunes: .padding(), .background(), .foregroundColor(), .font(), .frame()
• El orden importa: Los modificadores se aplican en secuencia

Text("¡Hola, Mundo!")
    .font(.title)
    .foregroundColor(.blue)
    .padding()
    .background(Color.yellow)
    .cornerRadius(10)
    .shadow(radius: 5)

// Modificador personalizado
struct PrimaryButtonStyle: ViewModifier {
    func body(content: Content) -> some View {
        content
            .padding()
            .background(Color.blue)
            .foregroundColor(.white)
            .cornerRadius(8)
    }
}

extension View {
    func primaryButton() -> some View {
        modifier(PrimaryButtonStyle())
    }
}

Frecuencia: Común Dificultad: Fácil

Datos y Redes (5 Preguntas)

16. ¿Cómo haces una petición de red en iOS?

Respuesta: Usa URLSession. En Swift moderno, una respuesta junior puede mostrar async/await y mencionar que bases de código antiguas aún usan completion handlers. Una respuesta más sólida también valida la respuesta HTTP, maneja errores, decodifica modelos Codable y actualiza la UI en el main actor.

struct User: Codable {
    let id: Int
    let name: String
}

func fetchUser(id: Int) async throws -> User {
    let url = URL(string: "https://api.example.com/users/\(id)")!
    let (data, response) = try await URLSession.shared.data(from: url)

    guard let http = response as? HTTPURLResponse, (200...299).contains(http.statusCode) else {
        throw URLError(.badServerResponse)
    }

    return try JSONDecoder().decode(User.self, from: data)
}

Frecuencia: Muy Común Dificultad: Media

17. ¿Qué es Codable en Swift?

Respuesta: Codable es un alias de tipo para los protocolos Encodable & Decodable. Permite una fácil conversión entre tipos de Swift y representaciones externas como JSON.

• Síntesis automática: Swift genera automáticamente código de codificación/decodificación si todas las propiedades son Codable.
• Claves personalizadas: Usa el enum CodingKeys para mapear diferentes nombres de propiedad.

struct User: Codable {
    let id: Int
    let name: String
    let email: String
}

// Decodificando JSON
let json = """
{
    "id": 1,
    "name": "John Doe",
    "email": "[email protected]"
}
""".data(using: .utf8)!

let decoder = JSONDecoder()
let user = try decoder.decode(User.self, from: json)

// Codificando a JSON
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
let jsonData = try encoder.encode(user)

Frecuencia: Muy Común Dificultad: Fácil

18. ¿Cómo persistes datos localmente en iOS?

Respuesta: Múltiples opciones para la persistencia de datos local:

• UserDefaults: Almacenamiento simple de clave-valor para pequeñas cantidades de datos (configuraciones, preferencias)
• Sistema de archivos: Guarda archivos en el directorio Documents o Cache
• Core Data: El framework de Apple para la gestión y persistencia de gráficos de objetos
• SQLite: Base de datos relacional
• Keychain: Almacenamiento seguro para datos confidenciales (contraseñas, tokens)

// UserDefaults
UserDefaults.standard.set("John", forKey: "username")
let username = UserDefaults.standard.string(forKey: "username")

// Sistema de archivos
let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
let filePath = documentsPath.appendingPathComponent("data.json")

// Escribir
try data.write(to: filePath)

// Leer
let loadedData = try Data(contentsOf: filePath)

Frecuencia: Muy Común Dificultad: Fácil

19. ¿Cuál es la diferencia entre operaciones síncronas y asíncronas?

Respuesta: Una operación síncrona bloquea el hilo actual hasta terminar. En el hilo principal es peligroso porque la app puede dejar de responder. Una operación asíncrona inicia el trabajo y deja que el hilo continúe; el resultado llega después mediante async/await, un completion handler, un delegate o un publisher.

En entrevistas iOS, conecta la respuesta con la fluidez de la UI: las llamadas de red, el trabajo con archivos y el procesamiento pesado no deben bloquear el main thread, y los cambios de UI deben ejecutarse en el main actor.

func loadProfile() async {
    do {
        let user = try await fetchUser(id: 42)
        await MainActor.run {
            self.nameLabel.text = user.name
        }
    } catch {
        await MainActor.run {
            self.errorLabel.text = "Could not load profile"
        }
    }
}

Frecuencia: Común Dificultad: Fácil

20. ¿Qué es Grand Central Dispatch (GCD)?

Respuesta: GCD es una API de bajo nivel de Apple para programar trabajo en dispatch queues. La main queue se usa para trabajo de UI, y las global queues pueden ejecutar trabajo en segundo plano con distintas prioridades de calidad de servicio.

En Swift moderno, a menudo usarás primero Swift concurrency (async/await, Task y actors) porque hace el código asíncrono más legible. GCD sigue siendo importante porque muchos proyectos UIKit, bases de código antiguas y APIs con callbacks usan DispatchQueue.main.async o colas de fondo.

DispatchQueue.global(qos: .userInitiated).async {
    let image = renderThumbnail()

    DispatchQueue.main.async {
        self.imageView.image = image
    }
}

Frecuencia: Común Dificultad: Media