isempty swift что это
Check empty string in Swift?
In Objective C, one could do the following to check for strings:
How does one detect empty strings in Swift?
15 Answers 15
Apple Pre-release documentation: «Strings and Characters».
A concise way to check if the string is nil or empty would be:
I am completely rewriting my answer (again). This time it is because I have become a fan of the guard statement and early return. It makes for much cleaner code.
Non-Optional String
Check for zero length.
If the if statement passes, then you can safely use the string knowing that it isn’t empty. If it is empty then the function will return early and nothing after it matters.
Optional String
Check for nil or zero length.
This unwraps the optional and checks that it isn’t empty at the same time. After passing the guard statement, you can safely use your unwrapped nonempty string.
In Xcode 11.3 swift 5.2 and later
If you want to ignore white spaces
Here is how I check if string is blank. By ‘blank’ I mean a string that is either empty or contains only space/newline characters.
You can also use an optional extension so you don’t have to worry about unwrapping or using == true :
To do the nil check and length simultaneously Swift 2.0 and iOS 9 onwards you could use
isEmpty will do as you think it will, if string == «», it’ll return true. Some of the other answers point to a situation where you have an optional string.
If the string is not nil, isEmpty will be used, otherwise it will not.
Below, the optionalString will NOT be set because the string is nil
Obviously you wouldn’t use the above code. The gains come from JSON parsing or other such situations where you either have a value or not. This guarantees code will be run if there is a value.
Массивы, наборы и словари в Swift всегда четко определяют типы значений и ключей, которые они могут хранить. Это означает, что вы не можете вставить значение неправильного типа в коллекцию по ошибке. Это также означает, что вы можете быть уверены в типе значений, которые вы получите из коллекции.
Изменчивость коллекций
Хорошей практикой является создание неизменных коллекций во всех случаях, когда коллекция не нуждается в изменении. Это облегчит вам анализ вашего кода и позволит компилятору Swift оптимизировать производительность создаваемых вами коллекций.
Массивы
Массив хранит значения одного и того же типа в упорядоченном списке. Одно и то же значение может появляться в массиве несколько раз в разных позициях.
Сокращенный синтаксис типа массива
Создание пустого массива
Вы можете создать пустой массив определенного типа, используя синтаксис инициализатора:
Обратите внимание, что тип someInts переменной выводится [Int] из типа инициализатора.
В качестве альтернативы, если контекст уже предоставляет информацию о типе, такую как аргумент функции или уже типизированная переменная или константа, вы можете создать пустой массив с литералом пустого массива, который записывается как [] (пустая пара квадратных скобок):
Создание массива со значением по умолчанию
Array Тип Swift также предоставляет инициализатор для создания массива определенного размера со всеми его значениями, установленными на одно и то же значение по умолчанию. Вы передаете этому инициализатору значение по умолчанию соответствующего типа (вызываемый repeating ): и сколько раз это значение повторяется в новом массиве (вызываемый count ):
Создание массива путем добавления двух массивов вместе
Вы можете создать новый массив, сложив вместе два существующих массива с совместимыми типами с помощью оператора сложения ( + ). Тип нового массива определяется по типу двух массивов, которые вы добавляете вместе:
Создание массива с литералом массива
В приведенном ниже примере создается массив, вызываемый shoppingList для хранения String значений:
В этом случае литерал массива содержит два String значения и ничего больше. Это соответствует типу shoppingList объявления переменной (массив, который может содержать только String значения), и поэтому присваивание литерала массива разрешено как способ инициализации shoppingList с двумя начальными элементами.
Благодаря выводу типа Swift вам не нужно писать тип массива, если вы инициализируете его литералом массива, содержащим значения того же типа. Инициализация shoppingList могла бы быть написана в более короткой форме:
Поскольку все значения в литерале массива имеют один и тот же тип, Swift может сделать вывод, что [String] это правильный тип для использования с shoppingList переменной.
Доступ и изменение массива
Вы получаете доступ к массиву и изменяете его через методы и свойства или с помощью синтаксиса нижнего индекса.
Чтобы узнать количество элементов в массиве, проверьте его count свойство только для чтения :
Используйте логическое isEmpty свойство в качестве ярлыка для проверки, count равно ли свойство 0 :
Вы можете добавить новый элемент в конец массива, вызвав метод массива append(_:) :
В качестве альтернативы добавьте массив из одного или нескольких совместимых элементов с помощью оператора присваивания сложения ( += ):
Вы можете использовать синтаксис нижнего индекса, чтобы изменить существующее значение по заданному индексу:
Когда вы используете синтаксис нижнего индекса, указанный вами индекс должен быть действительным. Например, запись для добавления элемента в конец массива приводит к ошибке во время выполнения. shoppingList[shoppingList.count] = «Salt»
Чтобы вставить элемент в массив по указанному индексу, вызовите метод массива insert(_:at:) :
Точно так же вы удаляете элемент из массива remove(at:) методом. Этот метод удаляет элемент по указанному индексу и возвращает удаленный элемент (хотя вы можете игнорировать возвращенное значение, если оно вам не нужно):
Любые пробелы в массиве закрываются при удалении элемента, и поэтому значение индекса 0 снова равно : «Six eggs»
Итерация по массиву
Если вам нужен целочисленный индекс каждого элемента, а также его значение, используйте enumerated() метод для перебора массива. Для каждого элемента в массиве enumerated() метод возвращает кортеж, состоящий из целого числа и элемента. Целые числа начинаются с нуля и считаются на единицу для каждого элемента; если вы перечислите по всему массиву, эти целые числа соответствуют индексам элементов. Вы можете разложить кортеж на временные константы или переменные как часть итерации:
наборы
А набор хранит различные значения одного и того же типа в сборе с не определяется упорядочением. Вы можете использовать набор вместо массива, когда порядок элементов не важен или когда вам нужно убедиться, что элемент появляется только один раз.
Хеш-значения для типов набора
Установить синтаксис типа
Создание и инициализация пустого набора
Вы можете создать пустой набор определенного типа, используя синтаксис инициализатора:
Тип letters переменной выводится Set из типа инициализатора.
Альтернативно, если контекст уже предоставляет информацию о типе, такую как аргумент функции или уже типизированная переменная или константа, вы можете создать пустой набор с литералом пустого массива:
Создание набора с литералом массива
Вы также можете инициализировать набор с помощью литерала массива, как краткий способ записать одно или несколько значений в виде набора множеств.
В приведенном ниже примере создается набор favoriteGenres для хранения String значений:
Тип набора не может быть выведен из одного только литерала массива, поэтому тип Set должен быть явно объявлен. Однако из-за вывода типа Swift вам не нужно писать тип элементов набора, если вы инициализируете его литералом массива, который содержит значения только одного типа. Инициализация favoriteGenres могла бы быть написана в более короткой форме:
Поскольку все значения в литерале массива имеют один и тот же тип, Swift может сделать вывод, что Set это правильный тип для использования с favoriteGenres переменной.
Доступ и изменение набора
Вы получаете доступ и изменяете набор через его методы и свойства.
Чтобы узнать количество элементов в наборе, проверьте его count свойство только для чтения :
Используйте логическое isEmpty свойство в качестве ярлыка для проверки, count равно ли свойство 0 :
Вы можете добавить новый элемент в набор, вызвав метод набора insert(_:) :
Чтобы проверить, содержит ли набор определенный элемент, используйте contains(_:) метод.
Итерация по множеству
Set Тип Swift не имеет определенного порядка. Чтобы перебрать значения набора в определенном порядке, используйте sorted() метод, который возвращает элементы набора в виде массива, отсортированного с помощью оператора.
Выполнение операций над множествами
Вы можете эффективно выполнять фундаментальные операции над множествами, например объединять два набора вместе, определять, какие значения имеют два общих набора, или определять, содержат ли два набора все, некоторые или ни одного из одинаковых значений.
Основные операции над множествами
Установить членство и равенство
Мобильная разработка. Swift: таинство протоколов
Сегодня мы продолжаем цикл публикаций на тему мобильной разработки под iOS. И если в прошлый раз речь шла о том, что нужно и не нужно спрашивать на собеседованиях, в этом материале мы коснемся тематики протоколов, которая имеет в Swift важное значение. Речь пойдет о том, как устроены протоколы, чем они отличаются друг от друга, и как сочетаются с интерфейсами Objective-C.
Как мы уже говорили ранее, новый язык Apple продолжает активно развиваться, и большинство его параметров и особенностей явно указаны в документации. Но кто читает документацию, когда код нужно написать здесь и сейчас? Поэтому давайте пройдемся по основным особенностям протоколов Swift прямо в нашем посте.
Для начала стоит оговориться, что протоколы Apple – это альтернативный термин для понятия «Интерфейс», которое применяется в других языках программирования. В Swift протоколы служат для того, чтобы обозначить шаблоны определенных структур (т.н. blueprint), с которыми можно будет работать на абстрактном уровне. Говоря простыми словами, протокол определяет ряд методов и переменных, которые в обязательном порядке должен наследовать определенный тип.
Далее в статье будут постепенно раскрываться моменты следующим образом: от простых и часто используемых к более сложным. В принципе, на собеседованиях можно давать вопросы в таком порядке, так как они определяют уровень компетенции соискателя — от уровня джунов до уровня сеньоров.
Для чего нужны протоколы в Swift?
Мобильные разработчики часто обходятся вообще без использования протоколов, но при этом теряется возможность работать с некоторыми сущностями абстрактно. Если выделить основные особенности протоколов в Swift, у нас получится следующие 7 пунктов:
При этом типы коллекций (сollection), а именно – array, set, dictionary – также можно упаковывать в протокол, потому что они тоже являются структурами. Например, словарь (Dictionary) определяется следующим образом
Обычно в объектно-ориентированном программировании применяется понятие классов, и всем хорошо знаком механизм наследования методов и переменных родительского класса классом-потомком. При этом никто не запрещает ему содержать дополнительные методы и переменные.
В случае с протоколами можно создать куда более интересную иерархию взаимосвязей. Для описания очередного класса можно использовать несколько протоколов одновременно, что позволяет создавать достаточно сложные конструкции, которые будут удовлетворять множеству условий одновременно. С другой стороны, ограничения разных протоколов позволяют сформировать некоторый объект, предназначенный только для узкого применения и содержащий определенный ряд функций.
Реализация протокола в Swift достаточно проста. Синтаксис подразумевает название, ряд методов и параметры (переменные), которые он будет содержать.
Кроме этого в Swift протоколы могут содержать не только наименования методов, но и их реализацию. Код метода в протоколе добавляются через расширения (extension). В документации можно найти много упоминаний расширений, но применительно к протоколам в расширениях можно размещать имя функции и тело функции.
То же самое можно делать с переменными.
Если мы где-то будем применять объект, связанный с протоколом, можно задать в нем переменную с фиксированным или передаваемым значением. Фактически переменная представляет собой небольшую функцию без входных параметров…или с возможностью прямого назначения параметра.
Расширение протокола в Swift позволяет реализовать тело переменной, и тогда она по факту будет представлять собой computed value – вычисляемый параметр с функциями get и set. То есть такая переменная не будет хранить никаких значений, а будет или играть роль функции или функций, или будет играть роль прокси для какой-то другой переменной.
Или если мы берем какой-то класс или структуру и реализуем протокол, то в нем можно использовать обычную переменную:
Стоит отметить, что переменные в определении протокола не могут быть weak. (weak – это вариант реализации переменой).
Есть и более интересные примеры: можно реализовать расширение массива и добавить туда функцию, связанную с типом данных массива. Например, если массив содержит целочисленные значения или имеет формат equitable (пригодные для сравнения), функция может, например, сравнивать все значения ячеек массива.
Небольшое замечание. Переменные и функции в протоколах могут быть статическими (static).
Использование @ objc
Главное, что нужно знать в данном вопросе — это то, что @ objc протоколы Swift видны в Objective-C коде. Строго говоря, для этого «волшебное слово» @ objc и существует. Но всё остальное остаётся без изменений
Протоколы такого типа могут быть наследоваными только классами. Для перечислений и структур это сделать нельзя.
То есть только так.
Стоит отметить, что в этом случае появляется возможность определять опциональные функции (@obj optional func), которые при желании можно не реализовывать, как для функции test() в предыдущем примере. Но условно опциональные функции можно реализовать и при помощи расширения протокола с пустой иплементацией.
Наследование типами
Создавая класс, структуру или перечисление, мы можем обозначить наследование определенного протокола – в этом случае унаследованные параметры будут работать и для нашего класса, и для всех остальных классов, которые наследуют этот класс, даже если мы не имеем к ним доступа.
Кстати, в этом контексте появляется одна очень интересная задачка. Допустим у нас есть протокол. Есть некоторый класс. И класс реализует протокол, а в нем есть функция work(). Что будет, если у нас есть extension протокола, в котором также есть метод work(). Какой из них будет вызван при обращении к методу?
Запущен будет метод класса – таковы уж особенности диспетчеризации методов в Swift. И этот ответ дают многие соискатели. Но вот на вопрос, как сделать так, чтобы в коде был выполнен не метод класса, а метод протокола, знают ответ лишь немногие. Однако и для этой задачи есть решение – оно подразумевает удалени функции из определения протокола и вызов метода следующим образом:
Generic-протоколы
В Swift также есть дженерик-протоколы (generic protocol) с абстрактными ассоциативными типами (associated types), которые позволяют определять переменные типов. Такому протоколу можно присваивать дополнительные условия, которые накладываются на ассоциативные типы. Несколько подобных протоколов позволяют выстраивать сложные конструкции, необходимые для формирования архитектуры приложения.
Однако реализовать переменную в виде дженерик-протокола нельзя. Его можно только наследовать. Эти конструкции используются для того, чтобы создавать зависимости в классах. То есть мы можем описать некоторый абстрактный generic-класс, чтобы определить используемые в нем типы.
Следует помнить, что дженерик-протоколы отличаются высоким уровнем абстракции. Поэтому в самих приложениях они могут быть излишними. Но при этом дженерик-протоколы используются при программировании библиотек.
Классовые протоколы
В Swift существуют также class-bound (ограниченные классом) протоколы. Для их описания применяется два вида синтаксиса
По словам разработчиков языка, использование этих синтаксисов равнозначно, но ключевое слово class используется только в этом месте, в отличие от AnyObject, который является протоколом.
Тем временем, как мы видим в ходе собеседований, люди часто не могут объяснить, что такое классовый протокол, и зачем он нужен. Его суть заключается в том, что мы получаем возможность использовать некоторый объект, которой был бы протоколом, и одновременно с этим функционировал бы как ссылочный тип. Пример:
В iOS используются управление памятью по методу automatic reference count, что подразумевает наличие сильных и слабых ссылок. И в некоторых случаях следует учитывать, какие именно — сильные (strong) или слабые (weak) – переменные используются в классах.
Проблема заключается в том, что при использовании некоторого протокола в качестве типа, при описании переменной (являющейся сильной ссылкой), может возникнуть циклические связи (retain cycle), приводящие к утечкам памяти, потому что объекты будут держаться везде сильными ссылками. Также неприятности могут возникнуть, если вы всё-таки решили писать код в соответствии с принципами SOLID.
Чтобы не возникали такие ситуации, в Swift используют классовые протоколы, которые позволяют изначально задавать «слабые» переменные. Классовый протокол разрешает держать объект слабой ссылкой. Пример, где это часто стоит учитывать, называется делегат.
Другой пример, где стоит использовать классовые протоколы, – это явное указание, что объект передается по ссылке.
Множественное наследование и диспетчеризация методов
Как говорилось в начале статьи, протоколы можно множественно наследовать. То есть,
Это полезно, но какие подводные камни здесь скрыты? Всё дело в том, что сложности, по крайней мере на первый взгляд, возникают из-за диспетчеризации методов (method dispatch). Говоря простыми словами, может быть непонятно, какой метод будет вызываться – родительский или из текущего типа.
Чуть выше, мы уже раскрыли тему того, как работает код, он вызывает метод класса. То есть, как ожидается.
Но если попробовать убрать сигнатуру метода из определения протокола, то происходит «магия». Собственно говоря, это вопрос из собеседования: «как сделать, чтобы вызвалась функция из протокола?»
Но если использовать переменную не как протокол, а как класс, то всё будет нормально.
Все дело в статической диспетчеризации методов при расширении протокола. И это надо учитывать. Причем тут множественное наследование? А вот при чем: если взять два протокола с реализованными функциями, такой код не сработает. Чтобы функция была выполнена, потребуется явно делать каст к нужному протоколу. Такой вот отголосок множественного наследования из C++.
Схожая история будет, если наследовать один протокол другим, где есть функции, которые реализуются в расширениях. Компилятор не даст его собрать.
Два последних примера показывают, что полностью заменять протоколы классами не стоит. Можно запутаться в статической диспетчеризации.
Дженерики и протоколы
Можно сказать, что это — вопрос со звёздочкой, который вовсе и не надо спрашивать. Но кодеры любят сверхабстрактные конструкции, и конечно, парочка ненужных generic class обязательно должны быть в проекте (куда ж без этого). Но программист не был бы программистом, если бы не захотел всё это обернуть это в ещё одну абстракцию. И Swift, являясь хоть и молодым, но динамично развивающимся языком, даёт такую возможность, но в ограниченном варианте. (да, это уже не про мобилки).
Во-первых, полноценная проверка на возможное наследование есть только в Swift 4.2, то есть только с осени будет возможность это нормально использовать в проектах. На Swift 4.1 выдаётся сообщение, что возможность ещё не реализована.
Для Swift 4.1 выводится следующее:
Тогда как в Swift 4.2 всё работает, как ожидается:
Также стоит заметить, что можно наследовать протокол только при одном типе связей. Если есть два типа связей, то наследование будет запрещено на уровне компилятора. Подробное объяснение того, что можно, а что нельзя, показано тут.
Но, не смотря на эти сложности, работа со связями в дженериках достаточно удобная.
Документация
Типы коллекций
Типы коллекций
Массивам, множествам и словарям в Swift всегда понятно, какие типы значений и ключи они могут хранить. Это означает, что вы не можете по ошибке вставить неверное значение в коллекцию. Это также означает, что вы можете быть уверены в типах значений, которые вы получите из коллекции.
Заметка
Забегая вперед, скажем, что Массив, Словарь и Множество в Swift реализованы как универсальные коллекции. Более подробную информацию об универсальных типах и коллекциях можно получить в главе «Универсальные шаблоны».
Изменчивость коллекций
Когда вы создаете массив или словарь и присваиваете его переменной, то созданная коллекция будет изменяемой. Это означает, что вы можете изменить коллекцию после ее создания путем добавления, удаления, или изменения элементов этой коллекции. И наоборот, когда вы присвоите массив или словарь константе, то он будет неизменяемым, а его размер и содержимое не может быть изменено.
Заметка
Хорошей практикой является создание неизменяемых коллекций во всех случаях, когда коллекцию не нужно менять. Делая это, мы позволяем компилятору Swift оптимизировать производительность наших коллекций.
Массивы
Массивы хранят много значений одинакового типа в упорядоченном списке. Одно и то же значение в массиве может появиться несколько раз, в разных позициях.
Заметка
Сокращённый синтаксис массивов
Хотя две формы функционально идентичны, краткая форма является предпочтительной и используется в данном руководстве при обращении к типу массива.
Создание пустого массива
Вы можете создать пустой массив определенного типа с помощью синтаксиса инициализатора:
Обратите внимание, что тип переменной someInts выводится как [Int] от типа инициализатора.
В качестве альтернативы, если контекст уже содержит информацию о типе, например, аргумент функции или уже типизированную переменную или константу, вы можете создать пустой массив с помощью пустого литерала массива, который записывается в виде [] (пустой пары квадратных скобок):
Создание массива с дефолтным значением
Тип массива в Swift также обеспечивает инициализатор для создания массива определенного размера со всеми его значениями, установленными на одно и тоже дефолтное значение. Вы передаете этому инициализатору дефолтное значение соответствующего типа (называемое repeating ): и сколько раз это значение повторяется в новом массиве (так называемый count ):
Создание массива, путем объединения двух массивов
Вы можете создать новый массив, объединив два существующих массива с совместимыми типами с оператором сложения ( + ). Новый тип массива выводится из типа двух массивов, которые вы объединяете вместе:
Создание массива через литералы массива
Вы можете инициализировать массив с помощью литерала массива, который является быстрым способом писать одно или несколько значений как набор значений массива.
Литерал массива пишется в виде списка значений, разделенных запятыми и окруженными парой (квадратных) скобок:
В приведенном ниже примере создается массив под названием shoppingList для хранения String значений:
Заметка
Массив shoppingList объявлен как переменная ( с помощью var ), а не константа ( с помощью let ), поскольку много элементов добавляются в список покупок в примерах ниже.
В данном случае литерал массива содержит два String значения и больше ничего. Это подходит типу, который мы присвоили при объявлении переменной shoppingList ( массив который может хранить только String значения), и поэтому присвоение литерала массива разрешено как способ инициализации shoppingList двумя начальными элементами.
Благодаря выводу типов Swift, вы можете не писать тип для массива, который вы инициализируйте с помощью литерала массива, хранящего значения того же типа. Вместо этого, инициализация shoppingList может быть записана в сокращенной форме:
Доступ и изменение массива
Вы можете получить доступ к массиву и изменять его либо через его методы и свойства, либо используя синтаксис сабскриптов.
Чтобы узнать количество элементов в массиве, проверьте его read-only свойство count :
Логическое свойство isEmpty можно использовать в качестве быстрого способа узнать, является ли свойство count равным 0 :
Вы можете добавить новый элемент в конец массива через вызов метода append :
Кроме того, добавить массив с одним или несколькими совместимыми элементами можно с помощью оператора сложения и присвоения ( += ):
Можно извлечь значение из массива с помощью синтаксиса сабскриптов, поместив индекс значения, который вы хотите получить, внутри квадратных скобок сразу после имени массива.
Заметка
Вы можете использовать синтаксис сабскриптов для изменения существующего значения данного индекса:
Для вставки элемента по заданному индексу внутрь массива, вызовите его метод insert(_:at:) :
Заметка
Любые пробелы внутри массива закрываются когда удаляется элемент, и поэтому значение с индексом 0 опять равно «Six eggs» :
Итерация по массиву
Вы можете выполнить итерацию по всему набору значений внутри массива с помощью цикла for-in :
Если вам нужен целочисленный индекс каждого значения так же как и само значение, используйте вместо этого глобальную функцию enumerated() для итерации по массиву. Функция enumerated() возвращает кортеж для каждого элемента массива, собрав вместе индекс и значение для этого элемента. Вы можете разложить кортеж во временные константы или переменные в рамках итерации:
Множества
Множество хранит различные значения одного типа в виде коллекции в неупорядоченной форме. Вы можете использовать множества как альтернативы массиву, когда порядок для вас значения не имеет или когда вам нужно быть уверенным в том, что значения внутри коллекции не повторяются.
Заметка
Получить больше информации об использовании множества с фреймворками Foundation и Cocoa можно в Bridging Between Set and NSSet.
Хеш значения для типа Set
Заметка
Для более подробной информации читайте главу «Протоколы».
Синтаксис типа множества
Создание и инициализация пустого множества
Вы можете создать пустое множество конкретного типа, используя синтаксис инициализатора:
Заметка
Альтернативно, если контекст предоставляет информацию о типе, например как аргумент функции или просто явное указание типа переменной или константы, то вы можете создать пустое множество при помощи пустого литерала массива:
Создание множества при помощи литерала массива
Вы так же можете инициализировать множество при помощи литерала массива, чтобы использовать его в качестве сокращенной записи нескольких элементов в качестве коллекции множества.
Заметка
Множество favoriteGenres объявлен как переменная (ключевое слово var ), но не константа (ключевое слово let ), так как мы добавляем и удаляем элементы в примере ниже.
Так как тип множества не может быть выведен только из литерала, то его тип должен быть указан явно. Однако из-за вывода типа в Swift вы не должны писать тип множества, если вы инициализируете его при помощи литерала массива, который содержит элементы одного типа. Вместо этого инициализация favoriteGenres может быть записана и в более короткой форме:
Доступ и изменение множества
Получить доступ и модифицировать множества можно через свойства и методы.
Для того, чтобы выяснить количество элементов в множестве вам нужно использовать свойство count :
Используйте булево свойство isEmpty в качестве сокращенной проверки наличия элементов во множестве или другими словами равно ли свойство count 0 :
Вы можете добавить новый элемент во множество, используя метод insert(_:) :
Можно проверить наличие определенного элемента во множестве, используя метод contains(_:) :
Итерация по множеству
Выполнение операций с множествами
Вы можете очень эффективно использовать базовые операции множеств, например, комбинирование двух множеств, определение общих значений двух множеств, определять содержат ли множества несколько, все или ни одного одинаковых значения.
Базовые операции множеств
Иллюстрации внизу изображают два множества a и b в результате применения различных методов.
Взаимосвязь и равенство множеств

Словари
Словарь представляет собой контейнер, который хранит несколько значений одного и того же типа. Каждое значение связано с уникальным ключом, который выступает в качестве идентификатора этого значения внутри словаря. В отличие от элементов в массиве, элементы в словаре не имеют определенного порядка. Используйте словарь, когда вам нужно искать значения на основе их идентификатора, так же как в реальном мире словарь используется для поиска определения конкретного слова.
Заметка
Сокращенный синтаксис словаря
Заметка
Создание пустого словаря
Подобно массивам вы можете создать пустой словарь определенного типа с помощью синтаксиса инициализатора:
Если контекст уже предоставляет информацию о типе, вы можете создать пустой словарь с помощью литерала пустого словаря, который пишется как [:] ( двоеточие внутри пары квадратных скобок):
Создание словаря с литералом словаря
Вы можете инициализировать словарь с помощью литерала словаря, который имеет схожий синтаксис с литералом массива, рассмотренного ранее. Литерал словаря это краткий способ написать одну или несколько пар ключ-значение в виде коллекций словаря.
Пара ключ-значение является комбинацией ключа и значения. В литерале словаря, ключ и значение в каждой паре ключ-значение разделено двоеточием. Пары ключ-значение написаны как список, разделенный запятыми и окруженный парой квадратных скобок:
Заметка
Словарь airports объявлен как переменная ( с помощью var ), а не константа ( с помощью let ), поскольку много аэропортов будет добавляться к словарю в примерах ниже.
Подобно массивам, вы можете не писать тип словаря если вы инициализируете его с помощью литерала словаря, чьи ключи и значения имеют соответствующие типы. Инициализация airports может быть записана в более краткой форме:
Поскольку все ключи в литерале имеют одинаковый тип, и точно так же все значения имеют одинаковый тип, то Swift может вывести, что [String: String] является правильным типом для использования в словаре airports.
Доступ и изменение словаря
Вы можете получить доступ к словарю и изменять его либо через его методы и свойства, либо используя синтаксис индексов. Подобно массивам, вы можете узнать количество элементов в словаре через его read-only свойство count :
Логическое свойство isEmpty можно использовать в качестве быстрого способа узнать, является ли свойство count равным 0 :
Вы можете добавить новый элемент в словарь с помощью синтаксиса индексов. Используйте новый ключ соответствующего типа в качестве индекса, а затем присвойте новое значение соответствующего типа:
Вы также можете использовать синтаксис индексов для изменения значения связанного с определенным ключом:
Метод updateValue(_:forKey:) возвращает опциональное значение соответствующее типу значения словаря. Например, для словаря, который хранит String значения, метод возвратит String? тип, или «опциональный String «. Это опциональное значение содержит старое значение для этого ключа, если оно существовало до обновления, либо nil если значение не существовало.
Вы также можете использовать синтаксис индексов чтобы получить значение из словаря для конкретного ключа. Поскольку есть вероятность запросить ключ для несуществующего значения, индекс словаря возвращает опциональное значение соответствующее типу значений словаря. Если словарь содержит значение для запрошенного ключа, индекс возвращает опциональное значение, содержащее существующее значение для этого ключа. В противном случае индекс возвращает nil :
Вы можете использовать синтаксис индексов для удаления пары ключ-значение из словаря путем присвоения nil значению для этого ключа:
Итерация по словарю
Вы также можете получить коллекцию ключей или значений словаря через обращение к его свойствам keys и values :
Тип словаря в Swift является неупорядоченной коллекцией. Для итерации по ключам или значениям словаря в определенной последовательности, используйте метод sorted() для свойств keys или values словаря.
Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.