Массивы в Swift: 5 фатальных ошибок при добавлении элементов (и как их избежать)

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Введение: Почему даже append может сломать код?

Казалось бы, что может быть проще, чем добавить элемент в массив в Swift? Мы пишем array.append(newElement) — и дело в шляпе. Однако, судя по тысячам просмотров на Stack Overflow, именно эта, на первый взгляд, тривиальная операция ставит в тупик как новичков, так и опытных разработчиков.

В этой статье мы не просто покажем, как добавить элемент в массив на Swift. Мы разберём 5 самых распространённых и коварных ошибок, которые превращают простой append в головную боль. Вы узнаете, почему компилятор может ругаться на, казалось бы, правильный код, как не вылететь за границы массива и в чём отличие append от insert. Поехали!

Ошибка №1: Забываем про строгую типизацию

Swift — язык со строгой типизацией. Это значит, что массив, объявленный как [Int], не примет строку, даже если она очень похожа на число. Это частая ловушка для тех, кто пришёл из Python или JavaScript.

Проблема: Несоответствие типов

var numbers: [Int] = [1, 2, 3]
// Ошибка компиляции: Cannot convert value of type 'String' to expected argument type 'Int'
numbers.append("4")

Решение: Приведение типов

Всегда явно приводите данные к типу массива. Используйте инициализаторы или явное преобразование:

var numbers: [Int] = [1, 2, 3]
if let intValue = Int("4") {
    numbers.append(intValue) // ✅ Работает: numbers = [1, 2, 3, 4]
}

// Или для строкового массива:
var strings: [String] = ["a", "b"]
strings.append(String(42)) // ✅ "42" добавлено как строка

Совет: Если вы добавляете элементы из внешнего источника (API, пользовательский ввод), всегда проверяйте тип с помощью as? или используйте compactMap для фильтрации nil.

Ошибка №2: Index out of range при использовании insert

Метод insert(_:at:) позволяет вставить элемент в произвольную позицию. Но если вы укажете индекс, который больше, чем количество элементов в массиве, приложение упадёт с Fatal error: Index out of range.

Проблема: Вставка за пределами массива

var fruits = ["Яблоко", "Банан"]
// Массив из 2 элементов: индексы 0 и 1
// Ошибка! Индекс 5 не существует
fruits.insert("Апельсин", at: 5)

Решение: Проверка границ и безопасное расширение

Есть два способа избежать этой ошибки:

Проверка индекса: Убедитесь, что индекс находится в диапазоне от 0 до array.count (включительно для insert).
Автоматическое дополнение: Если вы хотите вставить элемент в конец при выходе за границы, используйте логику с append.

var fruits = ["Яблоко", "Банан"]

// Безопасный вариант 1: проверка
let index = 5
if index >= 0 && index <= fruits.count {
    fruits.insert("Апельсин", at: index)
} else {
    // Если индекс больше count, просто добавляем в конец
    fruits.append("Апельсин")
}
print(fruits) // ["Яблоко", "Банан", "Апельсин"]

// Безопасный вариант 2: расширение (extension)
extension Array {
    mutating func safeInsert(_ element: Element, at index: Int) {
        if index >= 0 && index <= self.count {
            self.insert(element, at: index)
        } else {
            self.append(element)
        }
    }
}

fruits.safeInsert("Киви", at: 100) // ✅ Добавит в конец

Ошибка №3: Путаница между append и +=

Оператор += также может добавлять элементы, но его поведение отличается от append. Главное отличие: += работает с коллекциями, а не с одиночными элементами.

Проблема: Неявное создание массива

var list = [1, 2, 3]
list += 4 // ❌ Ошибка! Cannot convert value of type 'Int' to expected argument type '[Int]'

+= ожидает массив справа, даже если вы хотите добавить один элемент. Компилятор не поймёт вашего намерения.

Решение: Используйте append или оборачивайте в массив

var list = [1, 2, 3]

// Правильно: append
list.append(4) // ✅ [1, 2, 3, 4]

// Или: += с массивом
list += [5]    // ✅ [1, 2, 3, 4, 5]

// Добавление нескольких элементов
list += [6, 7, 8] // ✅ [1, 2, 3, 4, 5, 6, 7, 8]

Когда что использовать?

append — для добавления одного элемента. Это читаемее и безопаснее.
+= — для конкатенации целых массивов или добавления нескольких элементов за раз.

Ошибка №4: Игнорирование опциональных массивов

Массив может быть опциональным (var array: [Int]?). Попытка напрямую вызвать append на nil приведёт к крашу.

Проблема: Вызов append на nil

var optionalArray: [String]? = nil
// Fatal error: Unexpectedly found nil while unwrapping an Optional value
optionalArray!.append("Новый элемент")

Решение: Безопасное разворачивание

Всегда проверяйте опционал или используйте методы безопасного разворачивания:

var optionalArray: [String]? = nil

// Вариант 1: guard let
guard var array = optionalArray else {
    print("Массив nil, создаём новый")
    optionalArray = ["Первый"]
    return
}
array.append("Второй")
optionalArray = array

// Вариант 2: ?? (nil-coalescing)
optionalArray = (optionalArray ?? []) + ["Новый"]
// optionalArray теперь ["Новый"]

// Вариант 3: if let
if var array = optionalArray {
    array.append("Элемент")
    optionalArray = array
} else {
    optionalArray = ["Первый"]
}

Лайфхак: Если вы часто работаете с опциональными массивами, создайте extension:

extension Optional where Wrapped: RangeReplaceableCollection {
    mutating func append(_ element: Wrapped.Element) {
        if self == nil {
            self = Wrapped()
        }
        self?.append(element)
    }
}

var optArray: [Int]? = nil
optArray.append(10) // ✅ Безопасно: создаст массив и добавит элемент