Краткий ответ

ArraySlice обычно разделяет хранилище с исходным Array, поэтому небольшой срез может удерживать в памяти весь буфер большого массива. Если нужно сохранить срез надолго и освободить исходные данные, его следует явно скопировать в новый Array.

Исторический контекст

Срезы появились как эффективное представление части коллекции без немедленного копирования элементов. Такой подход позволяет быстро передавать подколлекции между операциями и сохраняет преимущества value semantics благодаря копированию при записи.

Цена эффективности — срез хранит связь с исходным хранилищем. Поэтому время создания среза обычно не зависит от количества выбранных элементов, но срок жизни этого среза может влиять на освобождение памяти.

Постановка проблемы

Представим, что из массива на несколько миллионов элементов выбирают десять значений и сохраняют результат в долгоживущем объекте. Даже после выхода исходного массива из области видимости небольшой ArraySlice может продолжать удерживать его буфер.

Это приводит к неожиданно большому потреблению памяти. Дополнительная особенность — индексы среза не обязаны начинаться с нуля, поэтому код, предполагающий индексацию как у нового массива, может обращаться к неверным позициям.

Подробное решение

ArraySlice является представлением диапазона исходной коллекции. Для Array он использует общее хранилище, а его startIndex и endIndex соответствуют позициям в исходном массиве.

func makeSlice() -> ArraySlice<Int> {
    let source = Array(0..<1_000_000)
    return source[10..<20]
}

let slice = makeSlice()
print(slice.startIndex)       // 10
let copied = Array(slice)
print(copied.startIndex)      // 0

После возврата из makeSlice срез всё ещё обращается к хранилищу исходного массива. Преобразование Array(slice) создаёт независимый массив только из выбранных элементов, поэтому исходный большой буфер после этого может быть освобождён.

При обходе следует использовать индексы самого среза, например его indices, а не предполагать диапазон от нуля. Срез сохраняет семантику значения: изменение среза не должно незаметно изменять исходный массив; при необходимости Swift применяет copy-on-write.

Копирование уменьшает удерживаемую память, но требует времени и дополнительного кратковременного выделения памяти. Оставление среза без копии выгодно для короткоживущих вычислений, однако рискованно для кэшей, свойств объектов и асинхронных задач.

Ситуация из практики

Сервис загружает большой массив записей, выбирает небольшой диапазон и помещает его в кэш. Рассматривались два варианта: хранить ArraySlice без копирования или сразу преобразовать его в Array.

Первый вариант быстрее и не требует копирования, но кэш удерживает весь исходный буфер. Второй вариант добавляет копирование выбранных элементов, зато размер долгоживущего объекта соответствует фактическому числу записей.

Для кэша выбран новый Array, поскольку его срок жизни значительно превышает время вычисления, а предсказуемое освобождение памяти важнее минимизации разовой операции копирования. Срезы оставлены только внутри коротких синхронных цепочек обработки.

Что кандидаты часто упускают

Обязательно ли индекс первого элемента ArraySlice равен нулю?

Нет. Срез сохраняет индексы исходной коллекции: если он получен из диапазона с началом 10, его startIndex обычно равен 10. Поэтому безопасный обход должен опираться на slice.indices, а не на ручную нумерацию от нуля.

Освобождается ли большой исходный Array сразу после создания маленького среза?

Не обязательно. Пока существует ArraySlice, он может сохранять ссылку на общее хранилище исходного массива. Для разрыва этой связи нужно создать независимый массив через Array(slice) и хранить уже его.

Изменит ли запись в ArraySlice исходный Array?

Нет, на это нельзя рассчитывать: коллекции Swift обладают семантикой значения. Если общим хранилищем пользуются несколько значений, мутация должна сохранить независимость значений, поэтому механизм copy-on-write может создать отдельную копию перед изменением.

Это означает, что срез удобен как эффективное представление для чтения, но не как способ намеренно передавать изменения обратно в исходный массив. Для явного изменения исходной коллекции следует работать с самим массивом или записать результат обратно.