Типы коллекций

Организуйте данные с помощью массивов, множеств и словарей.

Swift предоставляет три основных типа коллекций, известных как массивы, множества и словари, для хранения коллекций значений. Массивы представляют собой упорядоченные коллекции значений. Множества — неупорядоченные коллекции уникальных значений. Словари — неупорядоченные коллекции ассоциаций ключ-значение.

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

Примечание: типы массивов, множеств и словарей Swift реализованы как обобщенные коллекции. Подробнее об обобщенных типах и коллекциях см. в разделе Обобщения.

Изменяемость коллекций

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

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

Массивы

Массив хранит значения одного типа в упорядоченном списке. Одно и то же значение может появляться в массиве несколько раз в разных позициях.

Примечание: тип Array Swift сопоставлен с классом NSArray Foundation.

Дополнительную информацию об использовании Array с Foundation и Cocoa см. в разделе Сопоставление между Array и NSArray.

Краткая запись типа массива

Полная запись типа Swift массива записывается как Array<Element>, где Element — тип значений, которые массив разрешено хранить. Вы также можете записать тип массива в сокращенной форме как [Element]. Хотя оба формата функционально идентичны, сокращенная форма предпочтительнее и используется в данном руководстве при ссылке на тип массива.

Создание пустого массива

Вы можете создать пустой массив в Swift двумя способами. Если контекст уже предоставляет информацию о типе, например, аргумент функции или уже типизированная переменная или константа, вы можете использовать литерал пустого массива, который записывается как [] (пустая пара квадратных скобок):

var someInts: [Int] = []
print("someInts is of type [Int] with \(someInts.count) items.")
// Prints "someInts is of type [Int] with 0 items."

В качестве альтернативы вы можете создать пустой массив определенного типа, используя синтаксис явного инициализатора, записав тип элемента в квадратные скобки, за которыми следуют скобки — например, [Int]() в следующем примере:

var someInts = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")
// Prints "someInts is of type [Int] with 0 items."

Оба подхода дают одинаковый результат. Однако литерал пустого массива короче и обычно легче читается.

В обоих случаях вы можете использовать литерал пустого массива ([]) для повторного присвоения пустого массива существующей переменной:

someInts.append(3)
// someInts now contains 1 value of type Int
someInts = []
// someInts is now an empty array, but is still of type [Int]

Создание массива с заданным значением по умолчанию

Тип Array Swift также предоставляет инициализатор для создания массива определенного размера со всеми значениями, установленными на одно и то же значение по умолчанию. Вы передаете этому инициализатору значение по умолчанию соответствующего типа (называемое repeating) и количество повторений этого значения в новом массиве (называемое count):

var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]

Создание массива путем объединения двух массивов

Вы можете создать новый массив, объединив два существующих массива с совместимыми типами с помощью оператора сложения (+). Тип нового массива определяется по типу двух объединенных массивов:

var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// anotherThreeDoubles is of type [Double], and equals [2.5, 2.5, 2.5]

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles is inferred as [Double], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

Создание массива с помощью литерала массива

Вы также можете инициализировать массив с помощью литерала массива, что является кратким способом записи одного или нескольких значений как коллекции массива. Литерал массива записывается как список значений, разделенных запятыми, заключенных в пару квадратных скобок:

[<#value 1#>, <#value 2#>, <#value 3#>]

В приведенном ниже примере создается массив под названием shoppingList для хранения значений String:

var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList has been initialized with two initial items

Переменная shoppingList объявлена как «массив значений типа строка», записанный как [String]. Поскольку этот конкретный массив указал тип значения как String, он разрешено хранить только значения String. Здесь массив shoppingList инициализирован двумя значениями String ("Eggs" и "Milk"), записанными внутри литерала массива.

Примечание: массив shoppingList объявлен как переменная (с модификатором var), а не как константа (с модификатором let), потому что в последующих примерах в список покупок добавляются дополнительные элементы.

В данном случае литерал массива содержит два значения String и ничего больше. Это соответствует типу объявления переменной shoppingList (массив, который может содержать только значения String), поэтому присвоение литерала массива разрешено в качестве способа инициализации shoppingList двумя начальными элементами.

Благодаря инференции типов Swift вам не нужно писать тип массива, если вы инициализируете его литералом массива, содержащим значения одного типа. Инициализация shoppingList могла быть записана в более короткой форме:

var shoppingList = ["Eggs", "Milk"]

Поскольку все значения в литерале массива имеют один и тот же тип, Swift может определить, что [String] — это правильный тип для переменной shoppingList.

Доступ к массиву и его изменение

Доступ к массиву и его изменение осуществляется через его методы и свойства или с помощью синтаксиса индексирования.

Чтобы узнать количество элементов в массиве, проверьте его свойство только для чтения count:

print("The shopping list contains \(shoppingList.count) items.")
// Prints "The shopping list contains 2 items."

Используйте булево свойство isEmpty в качестве сокращения для проверки, равно ли свойство count свойству 0:

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list isn't empty.")
}
// Prints "The shopping list isn't empty."

Вы можете добавить новый элемент в конец массива, вызвав метод массива append(_:):

shoppingList.append("Flour")
// shoppingList now contains 3 items, and someone is making pancakes

В качестве альтернативы добавьте массив из одного или нескольких совместимых элементов с помощью оператора присваивания со сложением (+=):

shoppingList += ["Baking Powder"]
// shoppingList now contains 4 items
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList now contains 7 items

Получите значение из массива, используя синтаксис индексирования, передав индекс необходимого значения в квадратные скобки сразу после имени массива:

var firstItem = shoppingList[0]
// firstItem is equal to "Eggs"

Примечание: первый элемент в массиве имеет индекс 0, а не 1. Массивы в Swift всегда нулевого индекса.

Вы можете использовать синтаксис индексирования для изменения существующего значения по заданному индексу:

shoppingList[0] = "Six eggs"
// the first item in the list is now equal to "Six eggs" rather than "Eggs"

При использовании синтаксиса индексирования указанный индекс должен быть допустимым. Например, запись shoppingList[shoppingList.count] = "Salt" для добавления элемента в конец массива приведет к ошибке во время выполнения.

Вы также можете использовать синтаксис индексирования для одновременного изменения диапазона значений, даже если набор заменяющих значений имеет другую длину по сравнению с диапазоном, который вы заменяете. Следующий пример заменяет "Chocolate Spread", "Cheese" и "Butter" на "Bananas" и "Apples":

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList now contains 6 items

Чтобы вставить элемент в массив по указанному индексу, вызовите метод массива insert(_:at:):

shoppingList.insert("Maple Syrup", at: 0)
// shoppingList now contains 7 items
// "Maple Syrup" is now the first item in the list

Этот вызов метода insert(_:at:) вставляет новый элемент со значением "Maple Syrup" в самое начало списка покупок, указанный индексом 0.

Аналогично, вы удаляете элемент из массива с помощью метода remove(at:). Этот метод удаляет элемент по указанному индексу и возвращает удаленный элемент (хотя вы можете проигнорировать возвращаемое значение, если вам оно не нужно):

let mapleSyrup = shoppingList.remove(at: 0)
// the item that was at index 0 has just been removed
// shoppingList now contains 6 items, and no Maple Syrup
// the mapleSyrup constant is now equal to the removed "Maple Syrup" string

Примечание: если вы попытаетесь получить доступ к значению или изменить его по индексу, который выходит за пределы существующих границ массива, вы вызовете ошибку во время выполнения. Вы можете проверить, является ли индекс допустимым, сравнив его со свойством массива count. Наибольший допустимый индекс в массиве — count - 1, поскольку массивы индексируются с нуля — однако, когда count — 0 (то есть массив пуст), допустимых индексов нет.

Любые пробелы в массиве заполняются при удалении элемента, и поэтому значение по индексу 0 снова равно "Six eggs":

firstItem = shoppingList[0]
// firstItem is now equal to "Six eggs"

Если вы хотите удалить последний элемент из массива, используйте метод removeLast() вместо метода remove(at:), чтобы избежать необходимости запроса свойства массива count. Как и метод remove(at:), метод removeLast() возвращает удаленный элемент:

let apples = shoppingList.removeLast()
// the last item in the array has just been removed
// shoppingList now contains 5 items, and no apples
// the apples constant is now equal to the removed "Apples" string

Итерация по массиву

Вы можете перебрать все значения в массиве с помощью цикла for-in:

for item in shoppingList {
    print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

Если вам нужен целочисленный индекс каждого элемента, а также его значение, используйте метод enumerated() для итерации по массиву вместо этого. Для каждого элемента в массиве метод enumerated() возвращает кортеж, состоящий из целого числа и элемента. Целые числа начинаются с нуля и увеличиваются на единицу для каждого элемента; при переборе всего массива эти целые числа соответствуют индексам элементов. Вы можете разложить кортеж на временные константы или переменные в рамках итерации:

for (index, value) in shoppingList.enumerated() {
    print("Item \(index + 1): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

Дополнительную информацию о цикле for-in см. в разделе <doc:ControlFlow#For-In-Loops>.

Множества

Множество хранит различные значения одного типа в коллекции без определения порядка. Вы можете использовать множество вместо массива, когда порядок элементов не важен или когда необходимо гарантировать, что элемент появляется только один раз.

Примечание: тип Set Swift сопоставлен с классом NSSet Foundation.

Дополнительную информацию об использовании Set с Foundation и Cocoa см. в разделе Сопоставление между Set и NSSet.

Хеш-значения для типов множеств

Тип данных должен быть хешируемым, чтобы его можно было хранить в множестве — то есть, тип должен предоставлять способ вычисления хеш-значения для себя. Хеш-значение — это Int значение, которое одинаково для всех объектов, которые сравниваются одинаково, так что если a == b, хеш-значение a равно хеш-значению b.

Все базовые типы Swift (такие как String, Int, Double и Bool) по умолчанию являются хешируемыми и могут использоваться в качестве типов значений множества или типов ключей словаря. Значения перечисления без связанных значений (как описано в Перечисления) также по умолчанию хешируемы.

Примечание: Вы можете использовать свои собственные пользовательские типы в качестве типов значений множества или типов ключей словаря, сделав их совместимыми с протоколом Hashable из стандартной библиотеки Swift. Сведения об реализации требуемого метода hash(into:) см. в Hashable. Сведения о соответствии протоколам см. в Протоколы.

Синтаксис типа множества

Тип множества в Swift записывается как Set<Element>, где Element — это тип, который множество может хранить. В отличие от массивов, множества не имеют эквивалентной сокращенной формы.

Создание и инициализация пустого множества

Вы можете создать пустое множество определенного типа, используя синтаксис инициализатора:

var letters = Set<Character>()
print("letters is of type Set<Character> with \(letters.count) items.")
// Prints "letters is of type Set<Character> with 0 items."

Примечание: Тип переменной letters определяется по типу инициализатора и равен Set<Character>.

В качестве альтернативы, если контекст уже предоставляет информацию о типе, например, аргумент функции или уже типизированная переменная или константа, вы можете создать пустое множество с пустым литералом массива:

letters.insert("a")
// letters now contains 1 value of type Character
letters = []
// letters is now an empty set, but is still of type Set<Character>

Создание множества с литералом массива

Вы также можете инициализировать множество с литералом массива, как сокращённую запись для записи одного или нескольких значений как множество.

В примере ниже создаётся множество с именем favoriteGenres для хранения значений типа String:

var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGenres has been initialized with three initial items

Переменная favoriteGenres объявляется как «множество значений типа String», что записывается как Set<String>. Поскольку у этого конкретного множества задан тип значения String, оно может хранить только значения String. Здесь множество favoriteGenres инициализировано тремя значениями String ("Rock", "Classical" и "Hip hop"), записанными в литерале массива.

Примечание: Множество favoriteGenres объявлено как переменная (с модификатором var), а не как константа (с модификатором let), так как в следующих примерах элементы добавляются и удаляются.

Тип множества не может быть определён по одному только литералу массива, поэтому тип Set должен быть явно указан. Однако благодаря системе вывода типов Swift, вы можете не указывать тип элементов множества, если вы инициализируете его литералом массива, содержащим значения только одного типа. Инициализация favoriteGenres могла быть записана в более короткой форме:

var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

Поскольку все значения в литерале массива имеют один и тот же тип, Swift может определить, что Set<String> — это правильный тип для переменной favoriteGenres.

Доступ к множеству и изменение его

Доступ к множеству и изменение его производится через его методы и свойства.

Чтобы узнать количество элементов в множестве, проверьте его свойство только для чтения count:

print("I have \(favoriteGenres.count) favorite music genres.")
// Prints "I have 3 favorite music genres."

Используйте булево свойство isEmpty как сокращение для проверки, равно ли свойство count значению 0:

if favoriteGenres.isEmpty {
    print("As far as music goes, I'm not picky.")
} else {
    print("I have particular music preferences.")
}
// Prints "I have particular music preferences."

Добавить новый элемент в множество можно, вызвав метод множества insert(_:):

favoriteGenres.insert("Jazz")
// favoriteGenres now contains 4 items

Удалить элемент из множества можно, вызвав метод множества remove(_:), который удаляет элемент, если он является членом множества, и возвращает удалённое значение, или возвращает nil, если элемент в множестве отсутствовал. В качестве альтернативы, все элементы множества можно удалить с помощью метода removeAll().

if let removedGenre = favoriteGenres.remove("Rock") {
    print("\(removedGenre)? I'm over it.")
} else {
    print("I never much cared for that.")
}
// Prints "Rock? I'm over it."

Чтобы проверить, содержит ли множество определённый элемент, используйте метод contains(_:).

if favoriteGenres.contains("Funk") {
    print("I get up on the good foot.")
} else {
    print("It's too funky in here.")
}
// Prints "It's too funky in here."

Итерация по множеству

Вы можете итерироваться по значениям в множестве с помощью цикла for-in.

for genre in favoriteGenres {
    print("\(genre)")
}
// Classical
// Jazz
// Hip hop

Дополнительные сведения о цикле for-in см. в разделе <doc:ControlFlow#For-In-Loops>.

Тип Set Swift не имеет определённого порядка. Чтобы итерироваться по значениям множества в определённом порядке, используйте метод sorted(), который возвращает элементы множества как массив, отсортированный с помощью оператора <.

for genre in favoriteGenres.sorted() {
    print("\(genre)")
}
// Classical
// Hip hop
// Jazz

Выполнение операций над множествами

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

Основные операции над множествами

На иллюстрации ниже показаны два множества — a и b — с результатами различных операций над множествами, представленными заштрихованными областями.

• Используйте метод intersection(_:) для создания нового множества, содержащего только значения, общие для обоих множеств.
• Используйте метод symmetricDifference(_:) для создания нового множества, содержащего значения из любого множества, но не из обоих.
• Используйте метод union(_:) для создания нового множества, содержащего все значения из обоих множеств.
• Используйте метод subtracting(_:) для создания нового множества со значениями, не входящими в указанное множество.

let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(evenDigits).sorted()
// []
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
// [1, 9]
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
// [1, 2, 9]

Принадлежность множества и равенство

На иллюстрации ниже показаны три множества — a, b и c — с перекрывающимися областями, представляющими элементы, общие для множеств. Множество a является надмножеством множества b, потому что a содержит все элементы в b. Обратно, множество b является подмножеством множества a, потому что все элементы в b также содержатся в a. Множество b и множество c являются непересекающимися, потому что они не имеют общих элементов.

• Используйте оператор «равно» (==) для определения, содержат ли два множества все те же значения.
• Используйте метод isSubset(of:) для определения, содержатся ли все значения множества в указанном множестве.
• Используйте метод isSuperset(of:) для определения, содержит ли множество все значения в указанном множестве.
• Используйте методы isStrictSubset(of:) или isStrictSuperset(of:), чтобы определить, является ли множество подмножеством или надмножеством, но не равно указанному множеству.
• Используйте метод isDisjoint(with:) для определения, не имеют ли два множества общих значений.

let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]

houseAnimals.isSubset(of: farmAnimals)
// true
farmAnimals.isSuperset(of: houseAnimals)
// true
farmAnimals.isDisjoint(with: cityAnimals)
// true

Словари

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

Примечание: Тип Dictionary Swift связан с классом NSDictionary Foundation.

Дополнительную информацию об использовании Dictionary с Foundation и Cocoa см. в Связывание словаря и NSDictionary.

Сокращённый синтаксис типа словаря

Полная запись типа словаря в Swift — Dictionary<Key, Value>, где Key — тип значения, который может использоваться в качестве ключа словаря, а Value — тип значений, которые словарь хранит для этих ключей.

Примечание: Тип словаря Key должен соответствовать протоколу Hashable, как и тип значения множества.

Вы также можете записать тип словаря в сокращённой форме как [Key: Value]. Хотя эти две формы функционально идентичны, предпочтительнее использовать сокращённую форму, которая используется в этом руководстве при упоминании типа словаря.

Создание пустого словаря

Как и в случае с массивами, вы можете создать пустой Dictionary определённого типа, используя синтаксис инициализатора:

var namesOfIntegers: [Int: String] = [:]
// namesOfIntegers is an empty [Int: String] dictionary

В этом примере создаётся пустой словарь типа [Int: String] для хранения удобочитаемых имён целочисленных значений. Его ключи имеют тип Int, а значения — тип String.

Если контекст уже предоставляет информацию о типе, вы можете создать пустой словарь с пустым литералом словаря, который записывается как [:] (двоеточие внутри пары квадратных скобок):

namesOfIntegers[16] = "sixteen"
// namesOfIntegers now contains 1 key-value pair
namesOfIntegers = [:]
// namesOfIntegers is once again an empty dictionary of type [Int: String]

Создание словаря с литералом словаря

Вы также можете инициализировать словарь с литералом словаря, который имеет синтаксис, аналогичный литералу массива, увиденному ранее. Литерал словаря — это сокращённая запись для записи одной или нескольких пар «ключ-значение» как коллекцию Dictionary.

Пара «ключ-значение» — это комбинация ключа и значения. В литерале словаря ключ и значение в каждой паре «ключ-значение» разделяются двоеточием. Пары «ключ-значение» записываются как список, разделённый запятыми, заключённый в пару квадратных скобок:

[<#key 1#>: <#value 1#>, <#key 2#>: <#value 2#>, <#key 3#>: <#value 3#>]

В примере ниже создаётся словарь для хранения названий международных аэропортов. В этом словаре ключами являются трёхбуквенные коды Международной ассоциации воздушного транспорта, а значениями — названия аэропортов:

var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

Словарь airports объявлен как имеющий тип [String: String], что означает «словарь, ключи которого имеют тип String, а значения также имеют тип String».

Примечание: словарь airports объявлен как переменная (с помощью var оператора), а не как константа (с помощью let оператора), поскольку в примерах ниже добавляются новые аэропорты в словарь.

Словарь airports инициализирован с помощью литерала словаря, содержащего две пары ключ-значение. Первая пара имеет ключ "YYZ" и значение "Toronto Pearson". Вторая пара имеет ключ "DUB" и значение "Dublin".

Этот литерал словаря содержит две пары String: String. Этот тип ключ-значение соответствует типу объявления переменной airports (словарь с только String ключами и только String значениями), поэтому присвоение литерала словаря разрешено в качестве способа инициализации словаря airports с двумя начальными элементами.

Как и с массивами, вам не нужно указывать тип словаря, если вы инициализируете его с помощью литерала словаря, ключи и значения которого имеют согласованные типы. Инициализация airports могла бы быть записана в более короткой форме:

var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

Поскольку все ключи в литерале имеют одинаковый тип, а все значения также имеют одинаковый тип, Swift может определить, что [String: String] — это правильный тип для использования в словаре airports.

Доступ к словарю и изменение его содержимого

Вы можете получить доступ к словарю и изменить его содержимое через его методы и свойства или с помощью синтаксиса подстановочных значений.

Как и с массивом, вы можете узнать количество элементов в словаре Dictionary, проверив его свойство только для чтения count:

print("The airports dictionary contains \(airports.count) items.")
// Prints "The airports dictionary contains 2 items."

Используйте булево свойство isEmpty как сокращение для проверки, равно ли свойство count значению 0:

if airports.isEmpty {
    print("The airports dictionary is empty.")
} else {
    print("The airports dictionary isn't empty.")
}
// Prints "The airports dictionary isn't empty."

Вы можете добавить новый элемент в словарь с помощью синтаксиса подстановочных значений. Используйте новый ключ соответствующего типа в качестве индекса подстановки и присвойте новое значение соответствующего типа:

airports["LHR"] = "London"
// the airports dictionary now contains 3 items

Вы также можете использовать синтаксис подстановочных значений для изменения значения, связанного с определенным ключом:

airports["LHR"] = "London Heathrow"
// the value for "LHR" has been changed to "London Heathrow"

В качестве альтернативы подстановочным значениям используйте метод updateValue(_:forKey:) словаря для установки или обновления значения для определенного ключа. Как и в примерах с подстановками выше, метод updateValue(_:forKey:) устанавливает значение для ключа, если оно не существует, или обновляет значение, если этот ключ уже существует. Однако, в отличие от подстановки, метод updateValue(_:forKey:) возвращает прежнее значение после выполнения обновления. Это позволяет проверить, произошло ли обновление.

Метод updateValue(_:forKey:) возвращает необязательное значение типа значения словаря. Например, для словаря, хранящего String значения, метод возвращает значение типа String?, или «необязательное String». Это необязательное значение содержит старое значение для этого ключа, если оно существовало до обновления, или nil, если значение не существовало:

if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("The old value for DUB was \(oldValue).")
}
// Prints "The old value for DUB was Dublin."

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

if let airportName = airports["DUB"] {
    print("The name of the airport is \(airportName).")
} else {
    print("That airport isn't in the airports dictionary.")
}
// Prints "The name of the airport is Dublin Airport."

Вы можете использовать синтаксис подстановочных значений для удаления пары ключ-значение из словаря, присвоив значение nil для этого ключа:

airports["APL"] = "Apple International"
// "Apple International" isn't the real airport for APL, so delete it
airports["APL"] = nil
// APL has now been removed from the dictionary

В качестве альтернативы, удалите пару ключ-значение из словаря с помощью метода removeValue(forKey:). Этот метод удаляет пару ключ-значение, если она существует, и возвращает удалённое значение, или возвращает nil, если значение не существовало:

if let removedValue = airports.removeValue(forKey: "DUB") {
    print("The removed airport's name is \(removedValue).")
} else {
    print("The airports dictionary doesn't contain a value for DUB.")
}
// Prints "The removed airport's name is Dublin Airport."

Перебор словаря

Вы можете перебрать пары ключ-значение в словаре с помощью цикла for-in. Каждый элемент в словаре возвращается в виде кортежа (key, value), и вы можете разобрать члены кортежа в временные константы или переменные как часть итерации:

for (airportCode, airportName) in airports {
    print("\(airportCode): \(airportName)")
}
// LHR: London Heathrow
// YYZ: Toronto Pearson

Дополнительную информацию о цикле for-in см. в разделе <doc:ControlFlow#For-In-Loops>.

Вы также можете получить итерируемый набор ключей или значений словаря, обратившись к его свойствам keys и values:

for airportCode in airports.keys {
    print("Airport code: \(airportCode)")
}
// Airport code: LHR
// Airport code: YYZ

for airportName in airports.values {
    print("Airport name: \(airportName)")
}
// Airport name: London Heathrow
// Airport name: Toronto Pearson

Если вам нужно использовать ключи или значения словаря с API, который принимает экземпляр Array, инициализируйте новый массив с помощью свойства keys или values:

let airportCodes = [String](airports.keys)
// airportCodes is ["LHR", "YYZ"]

let airportNames = [String](airports.values)
// airportNames is ["London Heathrow", "Toronto Pearson"]

Тип Dictionary Swift не имеет определенного порядка. Чтобы перебрать ключи или значения словаря в определенном порядке, используйте метод sorted() для свойства keys или values.