Arreglos en Swift: 5 errores fatales al agregar elementos (y cómo evitarlos)

Introducción: ¿Por qué incluso append puede romper el código?

Podría parecer que no hay nada más simple que agregar un elemento a un arreglo en Swift. Escribimos array.append(newElement) y listo. Sin embargo, según los miles de visitas en Stack Overflow, esta operación, aparentemente trivial, desconcierta tanto a principiantes como a desarrolladores experimentados.

En este artículo no solo mostraremos cómo agregar un elemento a un arreglo en Swift. Analizaremos los 5 errores más comunes y engañosos que convierten un simple append en un dolor de cabeza. Aprenderá por qué el compilador puede quejarse de un código aparentemente correcto, cómo no salirse de los límites del arreglo y en qué se diferencia append de insert. ¡Comencemos!

Error n.º 1: Olvidar la tipificación estricta

Swift es un lenguaje de tipificación estricta. Esto significa que un arreglo declarado como [Int] no aceptará una cadena, incluso si se parece mucho a un número. Esta es una trampa común para quienes vienen de Python o JavaScript.

Problema: Discrepancia de tipos

var numbers: [Int] = [1, 2, 3]\n// Error de compilación: Cannot convert value of type 'String' to expected argument type 'Int'\nnumbers.append("4")\n

Solución: Conversión de tipos

Convierta siempre explícitamente los datos al tipo del arreglo. Use inicializadores o conversión explícita:

var numbers: [Int] = [1, 2, 3]\nif let intValue = Int("4") {\n    numbers.append(intValue) // ✅ Funciona: numbers = [1, 2, 3, 4]\n}\n\n// O para un arreglo de cadenas:\nvar strings: [String] = ["a", "b"]\nstrings.append(String(42)) // ✅ "42" agregado como cadena\n

Consejo: Si agrega elementos de una fuente externa (API, entrada del usuario), siempre verifique el tipo con as? o use compactMap para filtrar nil.

Error n.º 2: Index out of range al usar insert

El método insert(_:at:) permite insertar un elemento en una posición arbitraria. Pero si especifica un índice mayor que la cantidad de elementos en el arreglo, la aplicación fallará con un Fatal error: Index out of range.

Problema: Inserción fuera de los límites del arreglo

var fruits = ["Manzana", "Plátano"]\n// Arreglo de 2 elementos: índices 0 y 1\n// ¡Error! El índice 5 no existe\nfruits.insert("Naranja", at: 5)\n

Solución: Verificación de límites y extensión segura

Hay dos formas de evitar este error:

\n
• Verificación del índice: Asegúrese de que el índice esté en el rango de 0 a array.count (inclusive para insert).
\n
• Complemento automático: Si desea insertar un elemento al final cuando se sale de los límites, use la lógica con append.
\n

var fruits = ["Manzana", "Plátano"]\n\n// Opción segura 1: verificación\nlet index = 5\nif index >= 0 && index <= fruits.count {\n    fruits.insert("Naranja", at: index)\n} else {\n    // Si el índice es mayor que count, simplemente agregamos al final\n    fruits.append("Naranja")\n}\nprint(fruits) // ["Manzana", "Plátano", "Naranja"]\n\n// Opción segura 2: extensión (extension)\nextension Array {\n    mutating func safeInsert(_ element: Element, at index: Int) {\n        if index >= 0 && index <= self.count {\n            self.insert(element, at: index)\n        } else {\n            self.append(element)\n        }\n    }\n}\n\nfruits.safeInsert("Kiwi", at: 100) // ✅ Agregará al final\n

Error n.º 3: Confusión entre append y +=

El operador += también puede agregar elementos, pero su comportamiento difiere de append. La principal diferencia: += trabaja con colecciones, no con elementos individuales.

Problema: Creación implícita de un arreglo

var list = [1, 2, 3]\nlis