Какой subscript у массива?

Ответ на вопрос о subscript у массива в Swift

У массива в Swift существует индексный subscript, который позволяет получить или установить элемент по целочисленному индексу. Это основной способ доступа к элементам коллекции.

Базовый синтаксис

// Получение элемента по индексу
let array = [10, 20, 30, 40, 50]
let thirdElement = array[2] // 30

// Установка элемента по индексу
var mutableArray = [1, 2, 3, 4]
mutableArray[1] = 20 // Теперь массив [1, 20, 3, 4]

Range Subscript для получения среза

Массивы также поддерживают range subscript, который позволяет получить срез (ArraySlice) по диапазону индексов:

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// Получение среза с 3 по 7 элемент (индексы 2...6)
let slice = numbers[2...6] // ArraySlice [3, 4, 5, 6, 7]

// Получение среза с начала до 4 элемента
let prefixSlice = numbers[...4] // [1, 2, 3, 4, 5]

// Получение среза с 5 элемента до конца
let suffixSlice = numbers[5...] // [6, 7, 8, 9, 10]

Range Subscript для модификации нескольких элементов

var mutableNumbers = [10, 20, 30, 40, 50]

// Замена диапазона элементов
mutableNumbers[1...3] = [25, 35, 45]
// Теперь массив [10, 25, 35, 45, 50]

// Можно заменить разное количество элементов
mutableNumbers[2...4] = [100] 
// Теперь массив [10, 25, 100]

Важные особенности и безопасность

1. Проверка границ: Swift выполняет проверку выхода за границы массива, что предотвращает распространенные ошибки:

let array = [1, 2, 3]
// array[5] // Ошибка времени выполнения: fatal error: Index out of range

1. ArraySlice vs Array: Важно понимать разницу:

let array = [1, 2, 3, 4, 5]
let slice = array[1...3] // ArraySlice [2, 3, 4]

// ArraySlice - это представление оригинального массива
// Он хранит ссылку на оригинальный массив, а не копирует элементы
// Его можно преобразовать обратно в Array:
let newArray = Array(slice) // [2, 3, 4]

1. Partial ranges для удобства работы:

let names = ["Anna", "Boris", "Clara", "Dmitry"]

// Диапазон от начала до индекса 2 (включительно)
let firstThree = names[...2] // ["Anna", "Boris", "Clara"]

// Диапазон от индекса 1 до конца
let fromSecond = names[1...] // ["Boris", "Clara", "Dmitry"]

// Диапазон от начала до индекса 2 (не включая)
let upToTwo = names[..<2] // ["Anna", "Boris"]

Практические примеры использования

// Обмен двух элементов
var colors = ["red", "green", "blue", "yellow"]
(colors[0], colors[2]) = (colors[2], colors[0])
// Теперь ["blue", "green", "red", "yellow"]

// Быстрое удаление элементов
var numbers = [1, 2, 3, 4, 5, 6]
numbers[2...4] = [] // Удаляем элементы с индексами 2-4
// Теперь [1, 2, 6]

// Множественная вставка
var alphabet = ["a", "b", "c", "f", "g"]
alphabet[3...4] = ["d", "e", "f", "g"] // Вставляем недостающие элементы
// Теперь ["a", "b", "c", "d", "e", "f", "g"]

Поддержка пользовательских типов

Массивы также могут иметь custom subscript, если вы расширите их функциональность:

extension Array where Element: Numeric {
    subscript(safe index: Int) -> Element? {
        return indices.contains(index) ? self[index] : nil
    }
}

let safeArray = [1, 2, 3]
print(safeArray[safe: 5]) // nil (безопасный доступ)
print(safeArray[safe: 1]) // Optional(2)

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