swift удаление элемента из массива
Есть массив, который определен классом, т.е. состоит из переменных, в которых содержится текст типа String и изображение UIImage . Далее, по нажатию кнопки нужно узнать, есть ли эта переменная в массиве, например, с определенным именем, и если есть, то тогда удалить его из массива. Выглядит примерно так:
class QuestSub: NSObject, NSCoding
И eсть массив:
var questSubArray: [QuestSub] = [] Далее, есть переменные определенных объектов:
let key = (QuestSub(name: "Ключик", image: UIImage(named: "ключ")!)) Которые добавляем в массив:
questSubArray.append(key) И вот нужно узнать, если этот key в массиве, и если есть то удалить его.
Как работает массив в Swift
В прошлой статье мы поговорили про оценку относительной производительности структуры данных или алгоритма(Big O), теперь я предлагаю взглянуть на самый популярный тип данных — Массив и оценить основные методы взаимодействия с ним.
Массив — это набор элементов одного типа, которые можно устанавливать и извлекать через непрерывный ряд целых чисел, так называемые индексы.
Эти индексы, которые в большинстве компьютерных языков начинаются с нуля, определяют, где в массиве происходит действие.
Например, чтобы получить первый элемент нашего массива, мы бы сделали get запрос с нулевым индексом. Чтобы положить во второй ячейку массива, мы бы указали индекс, равный единице. С помощью индексов мы контролируем то, что входит и выходит из нашего массива.
О массивах нужно знать три вещи
- Во-первых, массивы могут содержать практически все, что угодно: числа, строки, объекты и даже другие массивы.
- Во-вторых, массивы имеют фиксированный размер. Вы не видите этого в Swift, потому что в Swift, когда мы создаем множество, мы не указываем его размер. Но во многих других компьютерных языках при инициализации массива вы должны дать ему начальный размер.
- В-третьих, у массивов есть уникальная возможность случайного доступа к данным через индекс.
Связанные списки не могут этого сделать. Стеки и очереди не могу этого сделать и даже бинарные деревья поиска, а массивы могут и в этом их сила.
Теперь давайте быстро рассмотрим основные операции работы с массивом, а также взглянем на него с точки зрения относительной производительности каждой из операций, начиная с get и set.
Возможность получать и устанавливать данные в любом месте за постоянное время — вот что делает массив таким популярным.
Независимо от того, насколько большим становится массив, если вы знаете индекс нужных вам элементов, вы можете просто добраться до него внутри и получить его за O(1) постоянное время.
Именно поэтому они есть почти в каждом компьютерном языке и почему они так популярны на интервью.
Есть еще три случая работы массивов, которые нам нужно рассмотреть, чтобы понять всю их природу. И это вставка(insert), удаление(delete), а также рост массива, и его способность изменить вместимость.
Начнем со вставки.
Когда мы вставляем элемент в массив, мы на самом деле делаем три вещи. Мы копируем, вставляем и увеличиваем размер. Допустим, мы хотим вставить символ B на место под индексом один. Когда мы передаем эту инструкцию в наш массив, нам сначала нужно скопировать ее вверх. Мы должны взять элементы в первом индексе и все, что над ними, и сдвинуть их вверх на одну ячейку. Как только мы это сделали, мы освободили место в первом индексе и можем вставить B. Затем, если мы отслеживаем, насколько велики массивы, мы также можем увеличить счетчик и изменить наш размер с трех до четырех.
Итак заметим, что в худшем случае, там, где нам приходится перебирать, иногда почти каждый элемент в массиве, и сдвигать все вверх время операции для этого фактически является линейным или O(n).
Удаление.
Удалить — это то же самое, что и вставить, только вместо копирования вверх здесь мы копируем вниз. Допустим, мы хотим удалить тот элемент B, который мы только что вставили с индексом один.
Здесь нам не нужно явно удалять B, мы можем просто взять все элементы выше индекса один — два, три, четыре и выше и просто сдвигайте их вниз и просто перезаписывайте все, что там было.
Оценка относительной производительности времени выполнения — линейная O(n), потому что в худшем случае пришлось бы сдвинуть каждый или почти элемент в массиве вниз на один, и это займет O(n) время.
Самое интересное начинается, когда наш массив просто недостаточно вместителен. Другими словами, что произойдет, если мы добавим элемент в конец нашего массива, например E, и нашему массиву, который, как мы знаем, имеет фиксированную вместительность четыре, просто некуда этот элемент положить?
В подобных ситуациях происходит удваивание размера массива.
Берем наш первоначальный массив, которого в данном случае будет четыре ячейки, создаем новый массив с размером восемь и затем мы копируем туда все существующие элементы. Переписываем A, B, C и D. Теперь, когда наш массив достаточно большой, мы можем добавить последний элемент E в самый конец под пятым индексом.
Из за изменения размера массива оценочное время O(n).
Давайте добавим E в самый конец этого массива.
Мы должны быть осторожны, потому что мы не можем просто вставить E в какую-то позицию, например, 99. Компилятор выдаст ошибку: индекс за пределами границ, потому что наш массив не достигает этого значения. Но если мы используем метод добавления(append), мы можем добавить E в конец нашего массива.
Обычное добавление элемента в массив происходит за постоянное время 0(1). Это очень, очень быстро, потому что обычно у нашего массива есть место, для нового элемента. Но в
тех редких случаях, когда нам нужно изменить вместимость массива, это будет O(n).
Рассмотрим несколько отличий массивов в Swift.
Единственное, что отличает массивы Swift, если вы пришли из других компьютерных языков, это то, что большая часть тяжелой работы, связанной с изменением размера массива, встроена прямо в сам объект массива. Если вы хотите создать массив, который может удалять, вставлять и добавлять элементы, на таком языке, как Java, или C, вам потребуется указать размер массива. В Swift все это сделано за вас. Обычно мы не указываем размер массивов. Мы просто инициализируем их, создаем, а затем используем.
Мы можем создавать массивы определенного размера, иногда такую задачу ставят на интервью, но довольно редко, поэтому вы не увидите такой код в реальном проекте.
let arrayOfSpecificSize = Array(repeating: "A", count: 10)Вывод:
- Массив имеет фиксированный размер.
- Рандомный доступ О(1).
- Вставка/ удаление – О(n).
- Массивы могут сокращаться и расти О(n).
- Swift проделывает большую работу за нас при создании массива.
Полезные ссылки:
- Apple Developer Documentation. Swift. Array
- Статья на Хабр: «Big O нотация в Swift»
- Перемещение массива в памяти
Как удалить элемент из массива swift
Массив представляет упорядоченную коллекцию элементов одного типа, к которым можно обратиться по индексу — номеру элемента в массиве. Индекс представляет число — объект типа Int и начинается с нуля. По сути массив представляет собой обычную переменную или константу, которая хранит несколько объектов наподобие кортежа.
Объявление массива
Объявление массива имеет следующие формы записи:
// Полная форма var имяМассива: Array // Краткая форма var имяМассива: [Тип]
var numbers: [Int]
Здесь объявлен массив numbers, который хранит объекты типа Int .
Но просто объявить массив недостаточно. Его, как и любую другую переменную, надо инициализировать перед использованием. То есть определить для него начальное значение. Все значения, которые входят в массив, перечисляются в квадратных скобках: [элемент1, элемент2, элемент3, . ] . Например:
var numbers: [Int] = [1, 2, 3, 4, 5] var numbers2: Array = [1, 2, 3, 4, 5] print(numbers)
Здесь массивы numbers и numbers2 содержит по 5 элементов. Мы также можем при объявлении не указывать тип массива, в этом случае система сама выведет тип исходя из входящих в него элементов:
var numbers = [1, 2, 3, 4, 5]
Мы также можем определить пустой массив:
var numbers = [Int]() // или так var numbers2 : [Int] = [] print("В массиве numbers \(numbers.count) элементов") // В массиве numbers 0 элементов
В таком массиве будет 0 элементов. С помощью свойства count можно получить количество элементов в массиве.
Доступ к элементам массива
Каждый элемент в массиве имеет определенный индекс, по которому мы можем получить или изменить элемент:
var numbers = [11, 12, 13, 14, 15] print(numbers[0]) // 11 numbers[0] = 21 print(numbers[0]) // 21
Для обращения к элементу массива после названия массива в квадратных скобках используется индекс элемента: numbers[0]
В данном случае у нас пять элементов в массиве, индексация в массивах начинается с нуля, поэтому первый элемент всегда имеет индекс 0, а последний элемент в данном случае будет иметь индекс 4. Если же мы попытаемся обратиться к элементу с большим индексом, например:
print(numbers[5]) // ошибка
То мы получим ошибку.
Если нам надо изменить несколько элементов подряд, то мы можем использовать операцию последовательности для записи индексов:
var numbers = [5, 6, 7, 8, 3] numbers[1. 3] = [105, 106, 103] print(numbers) // 5, 105, 106, 103, 3
В данном случае выражение 1. 3 указывает на набор индексов от 1 до 3. И таким образом, элементам с этими индексами мы можем присвоить значения.
Размер массива
С помощью свойства count можно получить число элементов массива:
var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] print("В массиве numbers \(numbers.count) элементов") // В массиве numbers 8 элементов
В дополнение к нему свойство isEmpty позволяет узнать, пуст ли массив. Если он пуст, то возвращается значение true :
var numbers: [Int] = [1, 4, 8] if numbers.isEmpty < print("массив пуст") >else
Перебор массива
С помощью цикла for можно перебрать элементы массива:
var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] for i in numbers < print(i) // 1, 2, 3, 4, 5, 6, 7, 8, >
Перебор массива через индексы:
var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] for i in 0 .. < numbers.count < print(numbers[i]) // 1, 2, 3, 4, 5, 6, 7, 8, >
Вместо применения цикла также можно использовать метод forEach() , которые перебирает все элементы. В качестве параметра этот метод принимает функцию, которая производит действия над текущим перебираемым элементом:
var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] numbers.forEach()
В данном случае передается анонимная функция, которая также с помощью функции print выводит значение элемента.
С помощью метода enumerated() можно одновременно получить индекс и значение элемента:
var names: [String] = [«Tom», «Alice», «Kate»] names.enumerated().forEach() for (index, value) in names.enumerated()
Создание массива из последовательности
Специальная форма инициализатора в качестве параметра принимает последовательность, из которой создается массив:
var numbers = Array (1. 5) // [1, 2, 3, 4, 5] var numbers2 = [Int] (3..<7) // [3, 4, 5, 6] print(numbers) // [1, 2, 3, 4, 5] print(numbers2) // [3, 4, 5, 6]
Еще одна форма инициализатора позволяет инициализировать массив определенным числом элементов одного значения:
var numbers = [Int] (repeating: 5, count: 3) // или так var numbers2 = Array (repeating: 5, count: 3) // эквивалентно массиву var numbers: [Int] = [5, 5, 5] print(numbers) // [5, 5, 5]
Однако стоит учитывать, что если подобным образом создается массив из объектов классов - ссылочных типов, то все элементы массива будут хранить ссылку на один и тот же элемент в памяти:
class Person < var name: String init(name: String)< self.name = name >> let tom = Person(name: "Tom") var people = Array (repeating: tom, count: 3) people[0].name = "Bob" for person in people < print(person.name) >// Bob // Bob // Bob
Сравнение массивов
Два массива считаются равными, если они содержат одинаковые элементы на соответствующих позициях:
var numbers: [Int] = [1, 2, 3, 4, 5] let nums = [1, 2, 3, 4, 5] if numbers == nums < print("массивы равны") >else
В данном случае массивы numbers и nums имеют одинаковое количество элементов, и все элементы на соответствующих позициях равны, поэтому оба массива равны.
Копирование массива
Массив является значимым типом, поэтому при копировании одного массива в другой второй массив получает копию первого:
var numbers: [Int] = [1, 2, 3, 4, 5] var nums: [Int] = numbers nums[0] = 78 print(numbers) // [1, 2, 3, 4, 5] print(nums) // [78, 2, 3, 4, 5]
С помощью последовательности можно задать набор индексов, по которым элементы копируются в другой массив:
var numbers: [Int] = [1, 2, 3, 4, 5] var nums = numbers[1. 3] print(nums[1]) // 2 print(nums) // [2, 3, 4]
В данном случае в массив nums копируются элементы из numbers с 1 по 3 индексы. При этом первым индексом в массиве nums будет не 0, а 1, так как именно с этого индекса производится копирование из numbers.
Добавление в массив
Для добавления элемента в массив применяется метод append() :
var numbers = [8, 11, 13, 14] numbers.append(20) print(numbers) // 8, 11, 13, 14, 20
Другой метод insert() управляет вставкой элемента в определенное место массива:
var numbers = [8, 11, 13, 14] numbers.insert(10, at: 3) // вставка числа 10 на 3-й индекс print(numbers) // 8, 11, 13, 10, 14
Удаление из массива
Ряд операций позволяют удалять элемент:
- remove(at: index) : удаляет элемент по определенному индексу
- removeFirst() : удаляет первый элемент
- removeLast() : удаляет последний элемент
- dropFirst() : удаляет первый элемент
- dropLast() : удаляет последний элемент
- removeAll() : удаляет все элементы массива
var numbers = [8, 11, 13, 14] numbers.remove(at: 2) // удаляем 3-й элемент print(numbers) // 8, 11, 14
Разница между методами removeFirst/removeLast и dropFirst/dropLast заключается в том, что первые возвращают удаленный элемент, а вторые - модифицированный массив:
var numbers = [8, 11, 13, 14] var n = numbers.removeFirst() // 8 var subNumbers = numbers.dropFirst() print(subNumbers) // [13, 14]
И если из массива необходимо удалить все элементы, применяется метод removeAll() :
var numbers = [8, 11, 13, 14] numbers.removeAll() print(numbers) // []
Сортировка массива
Для сортировки массива применяется метод sort
var numbers: [Int] = [10, 4, 12, 1, 3] numbers.sort() print(numbers) // [1, 3, 4, 10, 12]
Если метод sort сортирует оригинальный массив, то метод sorted() возвращает новый отсортированный массив, никак не изменяя старый:
var numbers: [Int] = [10, 4, 12, 1, 3] var nums = numbers.sorted() print(nums) // [1, 3, 4, 10, 12]
Обе функции принимают параметр by , который задает принцип сортировки. Он представляет функцию, которая принимает два параметра. Оба параметра представляют тип элементов массива. На выходе функция возвращает объект Bool. Если это значение равно true, то первое значение ставится до второго, если false - то после.
var numbers: [Int] = [10, 4, 12, 1, 3] numbers.sort(by: $1>) print(numbers) // [12, 10, 4, 3, 1] var nums = numbers.sorted(by: <) print(nums) // [1, 3, 4, 10, 12]
Выражение $1> представляет анонимную функцию, которая возвращает true, если значение первого параметра меньше второго, то есть в данном случае сортировка в обратном порядке. Мы можем задать более сложную логику, но в данном случае мы просто сравниваем два значения, поэтому мы можем упрастить данный вызов: numbers.sort(by: >) и Swift опять же будет применять операцию > к обоим параметрам.
Объединение массивов
С помощью операции сложения можно объединить два однотипных массива:
var numbers1 = [5, 6, 7] var numbers2 = [1, 2, 3] var numbers3 = numbers1 + numbers2 print(numbers3) // 5, 6, 7, 1, 2, 3
Фильтрация массивов
Для фильтрации массива применяется метод filter() , который возвращает отфильтрованный массив. В качестве параметра метод принимает функцию - если перебирает все эелементы и возвращает значение типа Bool. Если это значение - true, то элемент попадает в отфильтрованный массив:
var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] var filteredNums = numbers.filter() print(filteredNums) // [2, 4, 6, 8]
В данном случае метод filter принимает анонимную функцию, которая возвращает результат условия $0 % 2==0 , то есть если число делится на 2 без остатка (четное), то оно попадает в отфильтрованный массив.
Еще один способ фильтрации представляет метод prefix() . Он также возвращает отфильтрованный массив, при этом он перебирает подряд все элементы, пока условие возвращает true. Условие задается с помощью параметра while, который представляет функцию, возвращающую значение Bool:
var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] var filteredNums = numbers.prefix(while: ) print(filteredNums) // [1, 2, 3, 4]
Противоположным образом работает метод drop() - он, наоборт, удаляет все элементы до того, пока они не станут соответствовать условию:
var numbers: [Int] = [1, 2, 5, 3, 4, 5, 6, 7, 8] var filteredNums = numbers.drop(while: ) print(filteredNums) // [5, 3, 4, 5, 6, 7, 8]
Причем удаляются именно первые элементы, пока не найдется элемент, который удовлетворяет условию.
Преобразование массива
Метод map() проходит по всем элементам массива и преобразует их с помощью функции, которая передается в качестве параметра и которая возвращает преобразованный элемент. Преобразованные элементы помещаются в новый массив, который возвращается методом map:
var numbers: [Int] = [1, 2, 5, 3, 4, 5, 6, 7, 8] var mapedNums = numbers.map() print(mapedNums) // [1, 4, 25, 9, 16, 25, 36, 49, 64]
В данном случае метод map принимает анонимную функцию, которая возвращает квадрат числа. В итоге созданный массив будет содержать квадраты чисел из оригинального массива.
Многомерные массивы
Выше мы использовали простые массивы, которые можно представить в виду строки или расположить в ряд:
var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
Но мы можем создавать более сложные массивы, которые в качестве элементов могут включать в себя другие массивы:
var table = [[1,2,3], [4,5,6], [7,8,9]] // получаем вторую строку var row2 = table[1] // [4,5,6] // получаем первый элемент второй строки var cell1 = row2[0] // 4 // получаем второй элемент первой строки var cell2 = table[0][1] // 2
Внутри массива у нас три подмассива. Фактически данный массив можно представить как таблицу, в которой 3 строки. Выражение table[1] позволяет получить второй элемент - второй подмассив. А выражение row2[0] возвращает первый элемент этого подмассива.
Либо мы можем использовать набор квадратных скобок для доступа к элементам внутри подмассивов: table[0][1]
Подобным образом можно изменять элементы массива
// изменим вторую строку table[1] = [16, 25, 36] // изменим второй элемент первой строки table[0][1] = -12
При переборе стоит учитывать, что поскольку каждый элемент многомерного массива сам является массивом, то мы можем организовать вложенные циклы для их перебора:
// перебор по строкам for row in table < print(row) >// перебор таблицы по строкам и столбцам for row in table < for cell in row< print(cell) >>
Как удалить элемент из массива swift
Разработчик
Справочное руководство по библиотеке стандарта Swift
На этой странице
- Создание массива
- Доступ к элементам матрицы
- Добавление и удаление элементов
- Запросы массива
- Алгоритмы
- Операторы
Массив
Array универсальный тип, управляющий упорядоченным набором элементов, все из которых должны иметь тот же базовый тип ( T ).
Для получения дополнительной информации о Array , посмотрите Типы Набора.
Создание массива
init ()
Создает пустой массив типа T .
Объявление
Обсуждение
Создание массива с помощью этого инициализатора:
- var emptyArray = Array < Int >()
эквивалентно использованию синтаксиса удобства:
- var equivalentEmptyArray = [ Int ]()
init (count:repeatedValue:)
Создает массив с данным числом элементов, каждый инициализированный к тому же значению.
Объявление
- init ( count : Int , repeatedValue : T )
Обсуждение
Полученный массив будет иметь count элементы в нем, каждый инициализированный к тому же значению обеспечил как значение для repeatedValue .
- let numericArray = Array ( count : 3 , repeatedValue : 42 )
- // numericArray is [42, 42, 42]
- let stringArray = Array ( count : 2 , repeatedValue : "Hello" )
- // stringArray is ["Hello", "Hello"]
Доступ к элементам матрицы
нижний индекс (_: Интервал)
Получает или устанавливает существующие элементы в массиве с помощью преобразования в нижний индекс квадратной скобки.
Объявление
- subscript ( index : Int ) -> T
Обсуждение
Используйте преобразование в нижний индекс для доступа к отдельным элементам в любом массиве:
- var subscriptableArray = [ "zero" , "one" , "two" , "three" ]
- let zero = subscriptableArray [ 0 ]
- // zero is "zero"
- let three = subscriptableArray [ 3 ]
- // three is "three"
Если Вы объявляете массив с помощью var ключевое слово (т.е. как переменная), можно также использовать преобразование в нижний индекс для изменения значения любого существующего элемента в массиве:
- subscriptableArray [ 0 ] = "nothing"
- subscriptableArray [ 3 ] = "three items"
Не возможно вставить дополнительные элементы в преобразование в нижний индекс использования массива:
- subscriptableArray [ 4 ] = "new item"
- // Fatal error: Array index out of range
Если Вы хотите добавить дополнительные элементы к массиву, используйте append(_:) метод или += оператор вместо этого.
Вы не можете использовать преобразование в нижний индекс для изменения значения любого существующего элемента в массиве, что Вы объявляете использование let ключевое слово (т.е. как константа):
- let constantArray = [ "zero" , "one" , "two" , "three" ]
- constantArray [ 0 ] = "nothing"
- // Error: cannot mutate a constant array
нижний индекс (_: Диапазон )
Получает или устанавливает поддиапазон существующих элементов в массиве с помощью преобразования в нижний индекс квадратной скобки с целочисленным диапазоном.
Объявление
- subscript ( subRange : Range < Int >) -> Slice
Обсуждение
Используйте преобразование в нижний индекс диапазона для доступа к одному или более существующим элементам в любом массиве:
- var subscriptableArray = [ "zero" , "one" , "two" , "three" ]
- let subRange = subscriptableArray [ 1 . 3 ]
- // subRange = ["one", "two", "three"]
Если Вы объявляете массив с помощью var ключевое слово (т.е. как переменная), можно также использовать преобразование в нижний индекс для изменения значений диапазона существующих элементов:
- subscriptableArray [ 1 . 2 ] = [ "oneone" , "twotwo" ]
- // subscriptableArray is now ["zero", "oneone", "twotwo", "three"]
Вы не должны обеспечивать то же число элементов, как Вы заменяете:
- subscriptableArray [ 1 . 2 ] = []
- // subscriptableArray is now ["zero", "three"]
Не возможно вставить дополнительные элементы в преобразование в нижний индекс использования массива:
- subscriptableArray [ 4 . 5 ] = [ "four" , "five" ]
- // Fatal error: Array replace: subRange extends past the end
Если Вы хотите добавить дополнительные элементы к массиву, используйте append(_:) метод или += оператор вместо этого.
Вы не можете использовать преобразование в нижний индекс для изменения любых значений в массиве, что Вы объявляете использование let ключевое слово (т.е. как константа):
- let constantArray = [ "zero" , "one" , "two" , "three" ]
- constantArray [ 1 . 2 ] = []
- // Error: cannot mutate a constant array
Добавление и удаление элементов
добавьте (_:)
Добавляет новый элемент как последний элемент в существующем массиве.
Объявление
- mutating func append ( newElement : T )
Обсуждение
Используйте этот метод для добавления нового элемента к существующему массиву. Новый элемент будет добавлен как последний элемент в наборе:
- var array = [ 0 , 1 ]
- array . append ( 2 )
- // array is [0, 1, 2]
- array . append ( 3 )
- // array is [0, 1, 2, 3]
Если Вы объявили массив с помощью, можно только добавить новые значения к массиву var ключевое слово (т.е. как переменная и не константа):
- let constantArray = [ 0 , 1 ]
- constantArray . append ( 2 )
- // Error: cannot mutate a constant array
вставьте (_: atIndex:)
Вставляет элемент в набор в данном индексе.
Объявление
- mutating func insert ( newElement : T , atIndex i : Int )
Обсуждение
Используйте этот метод для вставки нового элемента где угодно в диапазоне существующих элементов, или как последний элемент:
- var array = [ 1 , 2 , 3 ]
- array . insert ( 0 , atIndex : 0 )
- // array is [0, 1, 2, 3]
Индекс должен быть меньше чем или равен числу элементов в наборе. При попытке вставить элемент в большем индексе, то Вы инициируете утверждение:
- array . insert ( 6 , atIndex : 6 )
- // Fatal error: Array replace: subRange extends past the end
Если Вы объявили массив с помощью, можно только вставить новые значения в массив var ключевое слово (т.е. как переменная и не константа):
- let constantArray = [ 1 , 2 , 3 ]
- constantArray . insert ( 0 , atIndex : 0 )
- // Error: cannot mutate a constant array
removeAtIndex (_:)
Удаляет элемент в данном индексе и возвращает его.
Объявление
- mutating func removeAtIndex ( index : Int ) -> T
Обсуждение
Используйте этот метод для удаления элемента в данном index . Возвращаемое значение метода является элементом, удаленным:
- var array = [ 0 , 1 , 2 , 3 ]
- let removed = array . removeAtIndex ( 0 )
- // array is [1, 2, 3]
- // removed is 0
Индекс должен быть меньше, чем число элементов в наборе. При попытке удалить элемент в большем индексе, то Вы инициируете утверждение:
- array . removeAtIndex ( 5 )
- // Fatal error: Array index out of range
Если Вы объявили массив с помощью, можно только удалить элемент из массива var ключевое слово (т.е. как переменная и не константа):
- let constantArray = [ 0 , 1 , 2 ]
- constantArray . removeAtIndex ( 0 )
- // Error: cannot mutate a constant array
removeLast ()
Удаляет последний элемент из набора и возвращает его.
Объявление
- mutating func removeLast () -> T
Обсуждение
Используйте этот метод для удаления последнего элемента в получателе. Возвращаемое значение метода является элементом, удаленным:
- var array = [ 1 , 2 , 3 ]
- let removed = array . removeLast ()
- // array is [1, 2]
- // removed is 3
Должен быть по крайней мере один элемент в массиве перед вызовом этого метода — при вызове этого метода на пустом массиве Вы инициируете утверждение:
- var emptyArray = [ Int ]()
- let tryToRemove = emptyArray . removeLast ()
- // Fatal error: can't removeLast from an empty Array
Если Вы объявили массив с помощью, можно только удалить последний элемент из массива var ключевое слово (т.е. как переменная и не константа):
- let constantArray = [ 1 , 2 ]
- constantArray . removeLast ()
- // Error: cannot mutate a constant array
removeAll (keepCapacity:)
Удаляет все элементы из набора, и по умолчанию очищает буфер базовой системы хранения.
Объявление
- mutating func removeAll ( keepCapacity : Bool = default )
Обсуждение
Используйте этот метод для удаления всех элементов в массиве:
- var array = [ 0 , 1 , 2 , 3 ]
- array . removeAll ()
- let count = array . count
- // count is 0
Если Вы не укажете иначе, базовая внешняя память будет очищена.
Если Вы объявили массив с помощью, можно только удалить все элементы из массива var ключевое слово (т.е. как переменная и не константа):
- let constantArray = [ 1 , 2 ]
- constantArray . removeAll ()
- // Error: cannot mutate a constant array
reserveCapacity (_:)
Гарантирует, что базовая система хранения может содержать данное общее количество элементов.
Объявление
- mutating func reserveCapacity ( minimumCapacity : Int )
Обсуждение
Гарантируйте, что массив имеет достаточно непрерывной базовой внешней памяти для хранения общего количества элементов, указанных для minimumCapacity .
Запросы массива
количество
Целочисленное значение, представляющее число элементов в массиве (только для чтения).
Объявление
- var count : Int
Обсуждение
Используйте это свойство только для чтения для запросов числа элементов в массиве:
- var array = [ "zero" , "one" , "two" ]
- let firstCount = array . count
- // firstCount is 3
- array += "three"
- let secondCount = array . count
- // secondCount is 4
isEmpty
Булево значение, определяющее, является ли массив пустым (только для чтения).
Объявление
- var isEmpty : Bool
Обсуждение
Используйте это свойство только для чтения, чтобы запросить, пуст ли массив:
- var array = [ "zero" , "one" , "two" , "three" ]
- let firstCheck = array . isEmpty
- // firstCheck is false
- array . removeAll ()
- let secondCheck = array . isEmpty
- // secondCheck is true
способность
Целочисленное значение, представляющее, сколько общие элементы массив могут сохранить без перераспределения (только для чтения).
Объявление
- var capacity : Int
Обсуждение
Используйте это свойство только для чтения для запросов, сколько общих элементов массив может сохранить, не инициировав перераспределение внешней памяти.
Алгоритмы
вид (_:)
Сортирует массив на месте с помощью данного закрытия для определения порядка предоставленной пары элементов.
Объявление
- mutating func sort ( isOrderedBefore : ( T , T ) -> Bool )
Обсуждение
Используйте этот метод для сортировки элементов в массиве. Закрытие, для которого Вы предоставляете isOrderedBefore должен возвратить булево значение, чтобы указать, должен ли один элемент быть прежде ( true ) или после ( false ) другой элемент:
- var array = [ 3 , 2 , 5 , 1 , 4 ]
- array . sort
- // array is [1, 2, 3, 4, 5]
- array . sort
- // array is [5, 4, 3, 2, 1]
Если Вы объявили массив с помощью, можно только сортировать массив на месте var ключевое слово (т.е. как переменная):
- let constantArray = [ 3 , 2 , 5 , 1 , 4 ]
- constantArray . sort
- // Error: cannot mutate a constant array
сортированный (_:)
Возвращает массив, содержащий элементы от массива, сортированного с помощью данного закрытия.
Объявление
- func sorted ( isOrderedBefore : ( T , T ) -> Bool ) -> [ T ]
Обсуждение
Используйте этот метод для возврата нового массива, содержащего сортированные элементы от массива. Закрытие, для которого Вы предоставляете isOrderedBefore должен возвратить булево значение, чтобы указать, должен ли один элемент быть прежде ( true ) или после ( false ) другой элемент:
- let array = [ 3 , 2 , 5 , 1 , 4 ]
- let sortedArray = array . sorted
- // sortedArray is [1, 2, 3, 4, 5]
- let descendingArray = array . sorted
- // descendingArray is [5, 4, 3, 2, 1]
реверс ()
Возвращает массив, содержащий элементы массива в обратном порядке индексом.
Объявление
- func reverse () -> [ T ]
Обсуждение
Используйте этот метод для возврата нового массива, содержащего элементы массива в обратном порядке; т.е. последний элемент будет первым, предпоследнее будет вторым и т.д.:
- let array = [ 1 , 2 , 3 , 4 , 5 ]
- let reversedArray = array . reverse ()
- // reversedArray = [5, 4, 3, 2, 1]
фильтр (_:)
Возвращает массив, содержащий элементы массива, для которого предоставленное закрытие указывает соответствие.
Объявление
- func filter ( includeElement : ( T ) -> Bool ) -> [ T ]
Обсуждение
Используйте этот метод для возврата нового массива путем фильтрации существующего массива. Закрытие, для которого Вы предоставляете includeElement: должен возвратить булево значение, чтобы указать, должен ли элемент быть включен ( true ) или исключенный ( false ) от заключительного набора:
- let array = [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ]
- let filteredArray = array . filter
- // filteredArray is [0, 2, 4, 6]
карта (_:)
Возвращает массив элементов, созданных из результатов применения предоставленного закрытия преобразования для каждого элемента в массиве.
Объявление
- func map < U >( transform : ( T ) -> U ) -> [ U ]
Обсуждение
Используйте этот метод для возврата нового массива, содержащего результаты применения предоставленного закрытия для преобразования каждого элемента в существующий массив:
- let array = [ 0 , 1 , 2 , 3 ]
- let multipliedArray = array . map
- // multipliedArray is [0, 2, 4, 6]
- let describedArray = array . map
- // describedArray is [Number: 0, Number: 1, Number: 2, Number: 3]
сократите (_: объединение:)
Возвращает единственное значение, представляющее результат применения предоставленного закрытия сокращения для каждого элемента.
Объявление
- func reduce < U >( initial : U , combine : ( U , T ) -> U ) -> U
Обсуждение
Используйте этот метод для сокращения набора элементов вниз к единственному значению путем рекурсивного применения предоставленного закрытия:
- let array = [ 1 , 2 , 3 , 4 , 5 ]
- let addResult = array . reduce ( 0 )
- // addResult is 15
- let multiplyResult = array . reduce ( 1 )
- // multiplyResult is 120
Два результата создают следующим образом:
- Параметрами первому вызову закрытия является начальное значение, которое Вы предоставляете и первый элемент в наборе. В addResult случай, означающий initialValue из 0 и первый элемент 1 : < 0 + 1 >. В multiplyResult случай, означающий initialValue из 1 и первый элемент 1 : .
- Затем, закрытие вызывают с предыдущим результатом как первый параметр и второй элемент как второй параметр. В addResult случай, означающий результат 1 и следующий элемент 2 : . В multiplyResult случай, означающий результат 1 и следующий элемент 2 : .
- Закрытия продолжают быть вызванными с предыдущим результатом и следующим элементом как параметры: В addResult означающий случай, , , , с конечным результатом 15 . В multiplyResult означающий случай, , , , с конечным результатом 120 .
Операторы
Добавляет элементы последовательности или набора к существующему массиву.
Объявление
Обсуждение
+= оператор предлагает простой способ добавить элементы последовательности или набора до конца существующего массива:
- var array = [ 0 , 1 , 2 , 3 ]
- array += [ 4 , 5 , 6 ]
- // array is [0, 1, 2, 3, 4, 5, 6]
Тип элементов в последовательности или наборе должен соответствовать тип существующих элементов в массиве:
- array += [ "hello" ]
- // Error: 'array' contains elements of type 'Int', not 'String'.
Можно только использовать += оператор для добавления элементов последовательности или набора к массиву, если Вы объявили массив с помощью var ключевое слово (т.е. как переменная и не константа):
- let constantArray = [ 0 , 1 , 2 ]
- constantArray += [ 3 ]
- // Error: cannot mutate a constant array