Cómo buscar un elemento en un array en Swift

Si eres un iOS Developer, independientemente de si estás dando tus primeros pasos o si ya tienes experiencia creando arquitecturas complejas, hay una estructura de datos con la que lidiarás todos los días: los Arrays (arreglos o matrices). Dominar la programación Swift implica conocer a fondo la Standard Library de Apple, y saber cómo buscar un elemento en un array en Swift de forma eficiente es una habilidad no negociable.

Ya sea que estés desarrollando la próxima gran aplicación para el iPhone, adaptando una interfaz fluida con SwiftUI, o escribiendo código multiplataforma para macOS y watchOS en Xcode, la forma en que buscas, filtras y manipulas colecciones de datos dicta el rendimiento y la legibilidad de tu proyecto.

En este mega-tutorial, exploraremos desde los métodos más básicos hasta las técnicas más avanzadas para buscar elementos en colecciones usando Swift.

1. Lo Esencial: Comprobando la Existencia de un Elemento

La necesidad más común en la programación Swift no es siempre saber dónde está un elemento, sino simplemente saber si existe.

El método contains(_:)

El método más rápido y semánticamente más claro para saber si un elemento existe en un array es contains. Este método devuelve un valor booleano (true o false).

let lenguajes = ["Swift", "Objective-C", "Python", "C++"]

// Buscar un elemento en un array en Swift usando contains
let tieneSwift = lenguajes.contains("Swift") // Devuelve true
let tieneJava = lenguajes.contains("Java")   // Devuelve false

if tieneSwift {
    print("¡Perfecto para un iOS Developer!")
}

Nota de rendimiento: El método contains(_:) tiene una complejidad de tiempo de O(n), lo que significa que en el peor de los casos, Swift tendrá que recorrer todo el array desde el principio hasta el final para encontrar tu elemento.

2. Encontrando la Posición: Índices en Swift

A veces, no basta con saber que el elemento está allí; necesitas su posición exacta para modificarlo o eliminarlo más adelante. Aquí es donde Xcode te autocompletará los métodos de indexación.

firstIndex(of:) y lastIndex(of:)

Como iOS Developer, a menudo trabajarás con listas dinámicas. firstIndex(of:) te devuelve la primera aparición de un elemento, mientras que lastIndex(of:) te devuelve la última. Ambos devuelven un Optional (Int?), ya que el elemento podría no existir.

let versionesiOS = [14, 15, 16, 17, 18, 15]

if let primerIndice = versionesiOS.firstIndex(of: 15) {
    print("La primera vez que aparece iOS 15 es en el índice: \(primerIndice)") // Imprime 1
}

if let ultimoIndice = versionesiOS.lastIndex(of: 15) {
    print("La última vez que aparece iOS 15 es en el índice: \(ultimoIndice)") // Imprime 5
}

Es crucial desempaquetar el valor opcional (usando if let o guard let) para evitar errores en tiempo de ejecución (crashes) en tu aplicación.

3. Búsquedas Avanzadas con Closures (Clausuras)

En el mundo real del desarrollo con SwiftUI y UIKit, raramente buscarás simples Strings o Ints. Lo más probable es que tengas arrays de modelos de datos complejos (Structs o Classes). ¿Cómo hacemos para buscar un elemento en un array en Swift cuando el criterio es complejo?

contains(where:)

Imagina que tienes una lista de usuarios y quieres saber si hay algún usuario mayor de edad.

struct Usuario {
    let nombre: String
    let edad: Int
}

let usuarios = [
    Usuario(nombre: "Ana", edad: 16),
    Usuario(nombre: "Carlos", edad: 22),
    Usuario(nombre: "Elena", edad: 17)
]

let hayAdultos = usuarios.contains { $0.edad >= 18 }
print(hayAdultos) // Devuelve true

first(where:)

Si en lugar de un booleano quieres extraer el objeto completo que cumple con tu condición, first(where:) es tu mejor amigo. Devuelve el primer elemento que coincida con la condición del closure.

if let primerAdulto = usuarios.first(where: { $0.edad >= 18 }) {
    print("El primer adulto encontrado es \(primerAdulto.nombre)") 
    // Imprime "El primer adulto encontrado es Carlos"
}

filter(_:)

¿Qué pasa si quieres todos los elementos que cumplen una condición, y no solo el primero? filter iterará sobre toda la colección y te devolverá un nuevo array con los resultados.

let menoresDeEdad = usuarios.filter { $0.edad < 18 }
print("Hay \(menoresDeEdad.count) menores de edad.") // Imprime 2

4. El Protocolo Equatable: La Clave para Tipos Personalizados

Un error muy común para el iOS Developer junior es intentar usar contains(of:) en un array de Structs personalizados y encontrarse con que Xcode arroja un error de compilación.

Swift es un lenguaje fuertemente tipado. Para que pueda comparar dos objetos y saber si son iguales, tu Struct o Class debe conformar el protocolo Equatable.

struct Dispositivo: Equatable {
    let modelo: String
    let capacidadGB: Int
}

let inventario = [
    Dispositivo(modelo: "iPhone 15 Pro", capacidadGB: 256),
    Dispositivo(modelo: "iPad Air", capacidadGB: 64)
]

let miTelefono = Dispositivo(modelo: "iPhone 15 Pro", capacidadGB: 256)

// Esto SOLO compila porque 'Dispositivo' conforma Equatable
let loTenemos = inventario.contains(miTelefono) 

Si no conformas Equatable, el compilador de Xcode no tiene forma de saber qué hace que dos Dispositivos sean idénticos (¿Es el nombre? ¿Es la capacidad? ¿Son ambos?).

5. Rendimiento: Cuándo el Array No Es la Mejor Opción

En la programación Swift, buscar en un array es rápido para colecciones pequeñas, pero a medida que tu array crece a miles de elementos, una búsqueda lineal (O(n)) puede afectar los frames por segundo (FPS) de tu interfaz en SwiftUI.

[Image of binary search algorithm flowchart]

Búsqueda Binaria (Binary Search)

Si tu array está ordenado previamente, puedes implementar una búsqueda binaria, lo que reduce el tiempo de búsqueda a O(log n). Aunque la Standard Library no incluye una función .binarySearch() nativa por defecto en colecciones regulares, puedes implementarla fácilmente o usar la funcionalidad que ofrece el framework Algorithms de Apple.

Alternativas: Sets y Dictionaries

Si tu aplicación requiere comprobar la existencia de elementos constantemente, considera convertir tu Array en un Set o usar un Dictionary. Las búsquedas en Sets y Diccionarios toman un tiempo constante (O(1)), lo que es increíblemente más rápido.

// Convertir un array en un Set para búsquedas ultrarrápidas
let identificadoresArray = ["ID1", "ID2", "ID3", "ID4"]
let identificadoresSet = Set(identificadoresArray)

// Esta búsqueda es O(1)
let existe = identificadoresSet.contains("ID3") 

6. Llevándolo a la Interfaz: Buscar en un Array usando SwiftUI

La teoría es genial, pero como iOS Developer, tu trabajo final se ve en la pantalla. SwiftUI hace que sea increíblemente fácil conectar un array filtrado a la interfaz de usuario usando el modificador .searchable.

Este código es completamente funcional tanto en iOS, como en macOS y watchOS.

import SwiftUI

struct BuscadorView: View {
    let frameworks = ["SwiftUI", "UIKit", "CoreData", "CloudKit", "Combine", "SpriteKit"]
    
    @State private var textoBusqueda = ""
    
    // Propiedad computada para filtrar el array
    var resultadosFiltrados: [String] {
        if textoBusqueda.isEmpty {
            return frameworks
        } else {
            return frameworks.filter { $0.localizedCaseInsensitiveContains(textoBusqueda) }
        }
    }
    
    var body: some View {
        NavigationView {
            List(resultadosFiltrados, id: \.self) { framework in
                Text(framework)
            }
            .navigationTitle("Frameworks Apple")
            // El modificador mágico de SwiftUI
            .searchable(text: $textoBusqueda, prompt: "Buscar framework...") 
        }
    }
}

¿Qué está pasando aquí?

1. Estado (@State): Mantenemos el texto que el usuario escribe en Xcode.
2. Propiedad Computada: Cada vez que el texto cambia, resultadosFiltrados evalúa el array original.
3. localizedCaseInsensitiveContains: Es vital usar esto en lugar de un simple .contains para cadenas de texto, ya que ignora mayúsculas y minúsculas (ej. “swiftui” encontrará “SwiftUI”).

7. Escribiendo Código Multiplataforma (iOS, macOS, watchOS)

Una de las maravillas de la programación Swift moderna es su portabilidad. Los métodos que hemos visto en este tutorial (contains, firstIndex, filter) son parte de la Swift Standard Library.

Esto significa que si estás programando en Xcode, el código lógico que escribes para buscar un elemento en un array en Swift para un iPhone (iOS), es exactamente el mismo que compilará para una app de escritorio de Mac (macOS) o una app para el Apple Watch (watchOS).

La única diferencia radicará en cómo presentas esa información al usuario a través de SwiftUI, ya que una pantalla de Apple Watch requiere una disposición de elementos diferente a la ventana redimensionable de un Mac.

Resumen y Mejores Prácticas

Ser un excelente iOS Developer requiere tomar las decisiones correctas en el momento adecuado. Aquí tienes tu hoja de trucos para arrays en Swift:

• Usa contains(_:) si solo necesitas saber si un elemento existe (true/false).
• Usa firstIndex(of:) si necesitas la posición exacta en el índice.
• Usa first(where:) si necesitas recuperar el primer objeto que cumpla una condición.
• Usa filter(_:) si necesitas una sub-colección con todos los elementos que coincidan.
• Implementa Equatable en tus modelos de datos personalizados para facilitar las búsquedas nativas.
• En interfaces de SwiftUI, utiliza el modificador .searchable junto con .filter para crear barras de búsqueda nativas y fluidas.

Si tienes cualquier duda sobre este artículo, contacta conmigo y estaré encantado de ayudarte . Puedes contactar conmigo en mi perfil de X o en mi perfil de Instagram