Swift язык программирования: объявления

Объявления

Объявление вводит новое имя или конструкцию в Вашу программу. Например, Вы используете объявления, чтобы представить функции и методы, переменные и константы, и определить новое, именованное перечисление, структуру, класс и типы протокола. Можно также использовать объявление, чтобы расширить поведение существующего именованного типа и импортировать символы в программу, объявляющиеся в другом месте.

В Swift большинство объявлений является также определениями в том смысле, что они реализованы или инициализированы одновременно, они объявляются. Однако потому что протоколы не реализуют свои элементы, большинство элементов протокола является объявлениями только. Для удобства и потому что различие не настолько важно в Swift, термин объявление покрывает и объявления и определения.

Грамматика объявления

объявление → объявление импорта -

объявление → постоянное объявление -

объявление → переменное объявление -

объявление → typealias-объявление -

объявление → функциональное объявление -

объявление → перечислимое объявление -

объявление → объявление структуры -

объявление → объявление класса -

объявление → объявление протокола -

объявление → объявление инициализатора -

объявление → deinitializer-объявление -

объявление → дополнительное объявление -

объявление → нижнее объявление -

объявление → объявление оператора -

объявления → «объявления объявления _{выбирают»}

Код верхнего уровня

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

Грамматика объявления верхнего уровня

высокоуровневое объявление → «операторы _{выбирает»}

Блоки кода

Блок кода используется множеством объявлений и управляющих структур для собирания в группу операторов. Это имеет следующую форму:

```
{
```
```
    statements
```
```
}
```

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

Грамматика блока кода

блок кода → {«операторы _{выбирают»}}

Объявление импорта

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

```
import module
```

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

```
import import kind module.symbol name
```
```
import module.submodule
```

Грамматика объявления импорта

объявление импорта → «атрибуты _{выбирает»}import«вид импорта _{выбирает} путь импорта»

вид импорта → typealias struct class enum protocol var func

путь импорта → идентификатор пути импорта - идентификатор пути импорта -.путь импорта -

идентификатор пути импорта → идентификатор - оператор -

Объявление константы

Объявление константы вводит постоянное именованное значение в Вашу программу. Объявления константы объявляются с помощью ключевого слова let и имейте следующую форму:

```
let constant name: type = expression
```

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

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

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

      let (firstNumber, secondNumber) = (10, 42)

В этом примере, firstNumber именованная константа для значения 10, и secondNumber именованная константа для значения 42. Обе константы могут теперь использоваться независимо:

      println("The first number is \(firstNumber).")
// prints "The first number is 10."
println("The second number is \(secondNumber).")
// prints "The second number is 42."

Аннотация типа (: введите), является дополнительным в объявлении константы, когда тип постоянного имени может быть выведен, как описано в Выводе типа.

Для объявления постоянного свойства типа отметьте объявление с static модификатор объявления. Введите свойства, обсуждены в Свойствах Типа.

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

Грамматика объявления константы

объявление константы → «атрибуты _{выбирает}, модификаторы объявления _{выбирают»}letсписок инициализатора образца -

список инициализатора образца → инициализатор образца - инициализатор образца -,список инициализатора образца -

инициализатор образца → «инициализатор образца _{выбирает»}

инициализатор → =выражение -

Объявление переменной

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

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

Можно переопределить свойство в подклассе путем маркировки объявления свойства подкласса с override модификатор объявления, как описано в Переопределении.

Сохраненные переменные и сохраненные переменные свойства

Следующая форма объявляет сохраненное переменное или сохранила переменное свойство:

```
var variable name: type = expression
```

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

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

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

Как их имена предполагают, значение сохраненной переменной или сохраненного переменного свойства сохранено в памяти.

Вычисленные переменные и вычисленные свойства

Следующая форма объявляет вычисленное переменное или вычисленное свойство:

```
var variable name: type {
```
```
get {
```
```
    statements
```
```
}
```
```
set(setter name) {
```
```
    statements
```
```
}
```
```
}
```

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

Метод get используется для чтения значения, и метод set используется для записи значения. Пункт метода set является дополнительным, и когда только метод get необходим, можно опустить оба пункта и просто возвратить требуемое значение непосредственно, как описано в Вычисленных Свойствах Только для чтения. Но если Вы обеспечиваете пункт метода set, необходимо также обеспечить пункт метода get.

Имя метода set и круглые скобки включения являются дополнительными. При обеспечении имени метода set оно используется в качестве имени параметра к методу set. Если Вы не обеспечиваете имя метода set, название параметра по умолчанию к методу set newValue, как описано в Кратком Объявлении Метода set.

В отличие от сохраненных именованных значений и сохраненных переменных свойств, значение вычисленного именованного значения или вычисленного свойства не сохранено в памяти.

Для получения дополнительной информации и видеть примеры вычисленных свойств, посмотрите Вычисленные Свойства.

Сохраненные переменные наблюдатели и наблюдатели свойства

Можно также объявить сохраненную переменную или свойство с willSet и didSet наблюдатели. Сохраненная переменная или свойство, объявленное с наблюдателями, имеют следующую форму:

```
var variable name: type = expression {
```
```
willSet(setter name) {
```
```
    statements
```
```
}
```
```
didSet(setter name) {
```
```
    statements
```
```
}
```
```
}
```

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

Можно добавить наблюдателей свойства к любому сохраненному свойству. Можно также добавить наблюдателей свойства к любому унаследованному свойству (или сохраненный или вычисленный) путем переопределения свойства в подклассе, как описано в Переопределении Наблюдателей Свойства.

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

willSet и didSet наблюдатели обеспечивают способ наблюдать (и ответить соответственно), когда устанавливается значение переменной или свойства. Когда переменная или свойство сначала инициализируются, наблюдателей не вызывают. Вместо этого их вызывают только, когда значение установлено за пределами контекста инициализации.

A willSet наблюдателя вызывают непосредственно перед тем, как значение переменной или свойства установлено. Новое значение передается willSet наблюдатель как константа, и поэтому это не может быть изменено в реализации willSet пункт. didSet наблюдателя сразу вызывают после того, как новое значение установлено. В отличие от willSet наблюдатель, старое значение переменной или свойства передается didSet наблюдатель в случае, если Вам все еще нужен доступ к нему. Однако если Вы присваиваете значение переменной или свойству в его собственном didSet пункт наблюдателя, что новое значение, которое Вы присваиваете, заменит тот, просто установленный и переданный willSet наблюдатель.

Имя метода set и круглые скобки включения в willSet и didSet пункты являются дополнительными. Если Вы обеспечиваете имена метода set, они используются в качестве названий параметра к willSet и didSet наблюдатели. Если Вы не обеспечиваете имена метода set, название параметра по умолчанию к willSet наблюдатель newValue и название параметра по умолчанию к didSet наблюдатель oldValue.

didSet пункт является дополнительным при обеспечении a willSet пункт. Аналогично, willSet пункт является дополнительным при обеспечении a didSet пункт.

Для получения дополнительной информации и видеть пример того, как использовать наблюдателей свойства, посмотрите Наблюдателей Свойства.

Свойства переменной типа

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

Грамматика объявления переменной

объявление переменной → «объявление переменной возглавляет список инициализатора образца»

объявление переменной → «объявление переменной возглавляет блок кода аннотации типа имени переменной»

объявление переменной → «объявление переменной возглавляет блок метода set метода get аннотации типа имени переменной»

объявление переменной → «объявление переменной возглавляет блок ключевого слова метода set метода get аннотации типа имени переменной»

объявление переменной variable-declaration-head-variable-name-initializer-willSet-didSet-block-

объявление переменной variable-declaration-head-variable-name-type-annotation-initializer-opt-willSet-didSet-block-

голова объявления переменной → «атрибуты _{выбирает}, модификаторы объявления _{выбирают»}var

имя переменной → идентификатор -

блок метода set метода get → {«пункт метода set пункта метода get _{выбирает»}}

блок метода set метода get → {«пункт метода get пункта метода set»}

пункт метода get → «атрибуты _{выбирает»}getблок кода -

пункт метода set → «атрибуты _{выбирает»}set«имя метода set _{выбирает} блок кода»

имя метода set → (идентификатор -)

ключевое слово метода set метода get блокирует → {«пункт ключевого слова метода set пункта ключевого слова метода get _{выбирает»}}

ключевое слово метода set метода get блокирует → {«пункт ключевого слова метода get пункта ключевого слова метода set»}

пункт ключевого слова метода get → «атрибуты _{выбирает»}get

пункт ключевого слова метода set → «атрибуты _{выбирает»}set

willSet-didSet-block {willSet-clause-didSet-clause-opt-}

willSet-didSet-block {didSet-clause-willSet-clause-opt-}

willSet-пункт → «атрибуты _{выбирает»}willSet«имя метода set _{выбирает} блок кода»

didSet-пункт → «атрибуты _{выбирает»}didSet«имя метода set _{выбирает} блок кода»

Введите объявление альтернативного имени

Объявление альтернативного имени типа представляет именованный псевдоним существующего типа в Вашу программу. Введите объявления альтернативного имени, объявляются с помощью ключевого слова typealias и имейте следующую форму:

```
typealias name = existing type
```

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

См. также Протокол Связанное Описание типа.

Грамматика объявления альтернативного имени типа

typealias-объявление → typealias-head-typealias-assignment-

typealias-возглавьте → «атрибуты _{выбирают}, модификатор уровня доступа _{выбирает»}typealiastypealias-имя -

typealias-назовите → идентификатор -

typealias-присвоение → =введите -

Объявление функции

Объявление функции вводит функцию или метод в Вашу программу. Функция, объявленная в контексте класса, структуры, перечисления или протокола, упоминается как метод. Объявления функции объявляются с помощью ключевого слова func и имейте следующую форму:

func function name(parameters) -> return type {

```
    statements
```
```
}
```

Если функция имеет тип возврата Void, тип возврата может быть опущен следующим образом:

```
func function name(parameters) {
```
```
    statements
```
```
}
```

Тип каждого параметра должен быть включен — это не может быть выведено. Несмотря на то, что параметры к функции являются константами по умолчанию, можно записать let перед именем параметра для подчеркивания этого поведения. Записать var перед именем параметра для создания его переменной, определяя объем любых изменений, внесенных в переменную только к телу функции или записи inout для внесения тех изменений также применяются к параметру, переданному в объеме вызывающей стороны. Для обсуждения изменяемых параметров посмотрите Изменяемые параметры.

Функции могут возвратить многократные значения с помощью типа «кортеж» в качестве типа возврата функции.

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

Названия параметра

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

```
parameter name: parameter type
```

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

      func f(x: Int, y: String) -> String {
    return y + String(x)
}
f(7, "hello")  // x and y have no name
 
class C {
    func f(x: Int, y: String) -> String {
        return y + String(x)
    }
}
let c = C()
c.f(7, y: "hello")  // x has no name, y has a name




  

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

external parameter name local parameter name: parameter type

```
#parameter name: parameter type
```
```
_ local parameter name: parameter type
```

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

Символ хеша (#) прежде чем название параметра указывает, что имя должно использоваться и в качестве внешнего и в качестве локального названия параметра. Это имеет то же значение как запись локального названия параметра дважды. Соответствующий параметр должен иметь это имя в вызовах функции или вызовах метода.

Подчеркивание (_) прежде чем локальное название параметра не дает тому параметру имени, которое будет использоваться в вызовах функции. Соответствующий параметр не должен иметь никакого имени в вызовах функции или вызовах метода.

Специальные виды параметров

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

```
_ : parameter type
```
```
parameter name: parameter type...
```

parameter name: parameter type = default argument value

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

Параметр с именем базового типа, сопровождаемым сразу тремя точками (...) понят как variadic параметр. Функция может иметь самое большее один variadic параметр, который должен быть его последним параметром. variadic параметр обрабатывается как массив, содержащий элементы имени базового типа. Например, variadic параметр Int... обрабатывается как [Int]. Для примера, использующего variadic параметр, см. Параметры Variadic.

Параметр с равняется знаку (=) и выражение после его типа, как понимают, имеет значение по умолчанию данного выражения. Когда функция вызвана, данное выражение оценено. Если параметр опущен при вызывании функции, значение по умолчанию используется вместо этого. Если параметр не опущен, он должен иметь свое имя в вызове функции.

      func f(x: Int = 42) -> Int { return x }
f()       // Valid, uses default value
f(x: 7)   // Valid, name and value provided
f(7)      // Invalid, value provided without its name

Специальные виды методов

Методы на изменяющих перечислении или структуре self должен быть отмечен с mutating модификатор объявления.

Методы, переопределяющие метод суперкласса, должны быть отмечены с override модификатор объявления. Это - ошибка времени компиляции для переопределения метода без override модификатор или использовать override модификатор на методе, не переопределяющем метод суперкласса.

Методы, связанные с типом, а не экземпляром типа, должны быть отмечены с static модификатор объявления для перечислений и структур или class модификатор объявления для классов.

Функции с приправой карри

Можно переписать функцию, берущую многократные параметры в качестве эквивалентной функции, берущей единственный параметр и возвращающей функцию. Возвращенная функция берет следующий параметр и возвращает другую функцию. Это продолжается, пока нет никаких остающихся параметров, в которой точке последняя функция возвращает возвращаемое значение исходной функции мультипараметра. Переписанная функция известна как функция с приправой карри. Например, можно переписать addTwoInts функционируйте как эквивалент addTwoIntsCurried функция:

      func addTwoInts(a: Int, b: Int) -> Int {
    return a + b
}
func addTwoIntsCurried(a: Int) -> (Int -> Int) {
    func addTheOtherInt(b: Int) -> Int {
        return a + b
    }
    return addTheOtherInt
}




  

addTwoInts функция берет два целых числа и возвращает результат добавления их вместе. addTwoIntsCurried функция берет единственное целое число и возвращает другую функцию, берущую второе целое число и добавляющую его к первому. (Вложенная функция получает значение первого целочисленного аргумента от функции включения.)

В Swift можно записать функцию с приправой карри более кратко с помощью следующего синтаксиса:

func function name(parameter)(parameter) -> return type {

```
    statements
```
```
}
```

Например, следующие два объявления эквивалентны:

      func addTwoIntsCurried(a: Int)(b: Int) -> Int {
    return a + b
}
func addTwoIntsCurried(a: Int) -> (Int -> Int) {
    func addTheOtherInt(b: Int) -> Int {
        return a + b
    }
    return addTheOtherInt
}




  

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

      addTwoInts(4, 5)
// returns a value of 9
addTwoIntsCurried(4)(b: 5)
// returns a value of 9

Несмотря на то, что необходимо обеспечить параметры функции нес приправой карри одновременно в единственном вызове, можно использовать форму с приправой карри функции для обеспечения параметров в нескольких вызовах функции, по одному (даже в различных местах в коде). Это известно как частичное функциональное приложение. Например, можно применяться addTwoIntsCurried функционируйте к целочисленному аргументу 1 и присвойте результат константе plusOne:

      let plusOne = addTwoIntsCurried(1)
// plusOne is a function of type Int -> Int

Поскольку plusOne относится к addTwoIntsCurried функция с ее параметром, связанным как значение 1, вызов plusOne с целочисленным аргументом просто добавляет 1 к параметру.

      plusOne(b: 10)
// returns a value of 11

Грамматика объявления функции

объявление функции → «функциональное главное имя функции универсальный пункт параметра _{выбирает} функциональное тело функции подписи»

функциональная голова → «атрибуты _{выбирает}, модификаторы объявления _{выбирают»}func

имя функции → идентификатор - оператор -

функциональная подпись → «результат функции пунктов параметра _{выбирает»}

функциональный результат → ->«атрибуты _{выбирают} тип»

тело функции → блок кода -

пункты параметра → «пункты параметра пункта параметра _{выбирают»}

пункт параметра → () (список параметра -..._{выберите} -)

список параметров → параметр - параметр -,список параметра -

параметр → inout_{выберите} -let_{выберите} -#_{«выберите}, внешнее название параметра _{выбирает}, локальный пункт параметра по умолчанию аннотации типа названия параметра _{выбирает»}

параметр → inout_{выберите} -var#_{«выберите}, внешнее название параметра _{выбирает}, локальный пункт параметра по умолчанию аннотации типа названия параметра _{выбирает»}

параметр → «атрибуты _{выбирает} тип»

внешнее название параметра → идентификатор - _

локальное название параметра → идентификатор - _

пункт параметра по умолчанию → =выражение -

Объявление перечисления

Объявление перечисления вводит именованный тип перечисления в Вашу программу.

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

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

В отличие от классов и структур, типы перечисления не имеют неявно предоставленного инициализатора по умолчанию; все инициализаторы должны быть объявлены явно. Инициализаторы могут делегировать к другим инициализаторам в перечислении, но процесс инициализации завершен только после того, как инициализатор присваивает один из случаев перечисления к self.

Как структуры, но в отличие от классов, перечисления являются типами значения; экземпляры перечисления копируются, когда присвоено переменным или константам, или, когда передано как параметры вызову функции. Для получения информации о типах значения посмотрите Структуры, и Перечисления Являются Типами Значения.

Можно расширить поведение типа перечисления с объявлением расширения, как обсуждено в Объявлении расширения.

Перечисления со случаями любого типа

Следующая форма объявляет тип перечисления, содержащий случаи перечисления любого типа:

enum enumeration name: adopted protocols {

```
    case enumeration case 1
```

    case enumeration case 2(associated value types)

```
}
```

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

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

Перечисления со случаями типа Необработанного Значения

Следующая форма объявляет тип перечисления, содержащий случаи перечисления того же основного типа:

enum enumeration name: raw-value type, adopted protocols {

    case enumeration case 1 = raw value 1

    case enumeration case 2 = raw value 2

```
}
```

В этой форме каждый блок случая состоит из ключевого слова case, сопровождаемый одним или более случаями перечисления, разделенными запятыми. В отличие от случаев в первой форме, каждый случай имеет базовое значение, названное необработанным значением, того же основного типа. Тип этих значений указан в типе необработанного значения и должен представлять целое число, число с плавающей точкой, строку или отдельный символ. В частности тип необработанного значения должен соответствовать Equatable протокол и один из следующих литерально-конвертируемых протоколов: IntegerLiteralConvertible для целочисленных литералов, FloatingPointLiteralConvertible для литералов с плавающей точкой, StringLiteralConvertible для строковых литералов, содержащих любое число символов, и ExtendedGraphemeClusterLiteralConvertible для строковых литералов, содержащих только отдельный символ.

Каждый случай должен иметь уникальное имя и быть присвоен уникальное необработанное значение. Если тип необработанного значения указан как Int и Вы не присваиваете значение случаям явно, они неявно присваиваются значения 0, 1, 2, и т.д. Каждый неприсвоенный случай типа Int неявно присваивается необработанное значение, автоматически постепенно увеличивающееся от необработанного значения предыдущего случая.

      enum ExampleEnum: Int {
    case A, B, C = 5, D
}

В вышеупомянутом примере, необработанном значении ExampleEnum.A 0 и значение ExampleEnum.B 1. И потому что значение ExampleEnum.C явно установлен в 5, значение ExampleEnum.D автоматически постепенно увеличивается от 5 и поэтому 6.

Перечисления, имеющие случаи типа необработанного значения неявно, соответствуют RawRepresentable протокол, определенный в библиотеке стандарта Swift. В результате у них есть a rawValue свойство и failable инициализатор с подписью init?(rawValue: RawValue). Можно использовать rawValue свойство для доступа к необработанному значению случая перечисления, как в ExampleEnum.B.rawValue. Если существует один, путем вызова failable инициализатора перечисления, как в, можно также использовать необработанное значение для нахождения соответствующего случая ExampleEnum(rawValue: 5), который возвращает дополнительный случай. Для получения дополнительной информации и видеть примеры случаев с типами необработанного значения, посмотрите Необработанные Значения.

Доступ к случаям перечисления

Для ссылки на случай типа перечисления используйте точку (.) синтаксис, как в EnumerationType.EnumerationCase. Когда тип перечисления может быть выведен из контекста, можно опустить его (точка все еще требуется), как описано в Синтаксисе Перечисления и Неявном Задействованном Выражении.

Для проверки значений случаев перечисления используйте a switch оператор, как показано в Соответствии Перечислимых величин с Оператором переключения. Тип перечисления является соответствующим образцу против образцов случая перечисления в блоках случая switch оператор, как описано в Образце Случая Перечисления.

Грамматика объявления перечисления

перечислимое объявление → «атрибуты _{выбирает}, модификатор уровня доступа _{выбирает} перечисление стиля объединения»

перечислимое объявление → «атрибуты _{выбирает}, модификатор уровня доступа _{выбирает}, необработанное значение разрабатывает перечисление»

перечисление стиля объединения → enum«универсальный пункт параметра имени перечисления _{выбирает}, пункт наследования типа _{выбирает»}{«перечислимые элементы стиля объединения _{выбирают»}}

элементы перечисления стиля объединения → «задействованные элементы перечисления стиля объединения перечисления стиля объединения _{выбирают»}

элемент перечисления стиля объединения → объявление - «пункт случая перечисления стиля объединения»

пункт случая перечисления стиля объединения → «атрибуты _{выбирает»}case«объединение разрабатывает перечислимый список случая»

случай перечисления стиля объединения перечисляет → «случай перечисления стиля объединения» «случай перечисления стиля объединения» ,«объединение разрабатывает перечислимый список случая»

случай перечисления стиля объединения → «перечислимый тип «кортеж» имени случая _{выбирает»}

перечислимое имя → идентификатор -

перечислимое имя случая → идентификатор -

необработанное перечисление стиля значения → enum«универсальный пункт параметра имени перечисления _{выбирает} пункт наследования типа»{«необработанное значение разрабатывает перечислимые элементы»}

необработанные элементы перечисления стиля значения → «перечислимые элементы стиля значения сырых данных перечислимого элемента стиля необработанного значения _{выбирают»}

необработанный элемент перечисления стиля значения → объявление - «необработанное значение разрабатывает перечислимый пункт случая»

необработанный пункт случая перечисления стиля значения → «атрибуты _{выбирает»}case«необработанное значение разрабатывает перечислимый список случая»

необработанный случай перечисления стиля значения перечисляет → «перечислимый случай стиля необработанного значения» «перечислимый случай стиля необработанного значения» ,«необработанное значение разрабатывает перечислимый список случая»

необработанный случай перечисления стиля значения → «перечислимое присвоение значения сырых данных имени случая _{выбирает»}

необработанное присвоение значения → =необработанный литерал значения -

необработанный литерал значения → числовой литерал - строковый литерал - булев литерал -

Описание структуры

Описание структуры вводит именованный тип структуры в Вашу программу. Описания структуры объявляются с помощью ключевого слова struct и имейте следующую форму:

struct structure name: adopted protocols {

```
    declarations
```
```
}
```

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

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

Существует три пути, создают экземпляр ранее заявленной структуры:

Вызовите один из инициализаторов, объявленных в структуре, как описано в Инициализаторах.
Если никакие инициализаторы не объявляются, вызовите memberwise инициализатор структуры, как описано в Инициализаторах Memberwise для Типов Структуры.
Если никакие инициализаторы не объявляются, и всем свойствам описания структуры дали начальные значения, вызывают инициализатор структуры по умолчанию, как описано в Инициализаторах По умолчанию.

Процесс инициализации заявленных свойств структуры описан в Инициализации.

К свойствам экземпляра структуры можно получить доступ с помощью точки (.) синтаксис, как описано в Доступе к Свойствам.

Структуры являются типами значения; экземпляры структуры копируются, когда присвоено переменным или константам, или, когда передано как параметры вызову функции. Для получения информации о типах значения посмотрите Структуры, и Перечисления Являются Типами Значения.

Можно расширить поведение типа структуры с объявлением расширения, как обсуждено в Объявлении расширения.

Грамматика описания структуры

объявление структуры → «атрибуты _{выбирает}, модификатор уровня доступа _{выбирает»}struct«универсальный пункт параметра имени структуры _{выбирает}, пункт наследования типа _{выбирает} организация структуры»

имя структуры → идентификатор -

организация структуры → {«объявления _{выбирают»}}

Объявление класса

Объявление класса вводит именованный тип класса в Вашу программу. Объявления класса объявляются с помощью ключевого слова class и имейте следующую форму:

class class name: superclass, adopted protocols {

```
    declarations
```
```
}
```

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

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

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

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

Чтобы потребовать, чтобы подклассы реализовали инициализатор суперкласса, отметьте инициализатор суперкласса с required модификатор объявления. Реализация подкласса того инициализатора должна также быть отмечена с required модификатор объявления.

Несмотря на то, что свойства и методы, объявленные в суперклассе, наследованы текущим классом, определяемые инициализаторы, объявленные в суперклассе, не. Однако если текущий класс переопределяет все определяемые инициализаторы суперкласса, он наследовал инициализаторы удобства суперкласса. Классы Swift не наследовались от универсального базового класса.

Существует два пути, создают экземпляр ранее заявленного класса:

Вызовите один из инициализаторов, объявленных в классе, как описано в Инициализаторах.
Если никакие инициализаторы не объявляются, и всем свойствам объявления класса дали начальные значения, вызывают инициализатор класса по умолчанию, как описано в Инициализаторах По умолчанию.

Свойства доступа экземпляра класса с точкой (.) синтаксис, как описано в Доступе к Свойствам.

Классы являются ссылочными типами; экземпляры класса именуются, а не копируются, когда присвоено переменным или константам, или, когда передано как параметры вызову функции. Для получения информации о ссылочных типах посмотрите Структуры, и Перечисления Являются Типами Значения.

Можно расширить поведение типа класса с объявлением расширения, как обсуждено в Объявлении расширения.

Грамматика объявления класса

объявление класса → «атрибуты _{выбирает}, модификатор уровня доступа _{выбирает»}class«имя класса, универсальный пункт параметра _{выбирает} пункт наследования типа_{, выбирает} организация класса»

имя класса → идентификатор -

организация класса → {«объявления _{выбирают»}}

Объявление протокола

Объявление протокола вводит именованный тип протокола в Вашу программу. Объявления протокола объявляются в глобальной области видимости с помощью ключевого слова protocol и имейте следующую форму:

protocol protocol name: inherited protocols {

```
    protocol member declarations
```
```
}
```

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

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

Можно добавить соответствие протокола к ранее заявленному типу путем принятия протокола в объявлении расширения того типа. В расширении необходимо реализовать все требования принятого протокола. Если тип уже реализует все требования, можно оставить организацию объявления расширения пустой.

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

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

      protocol SomeProtocol: class {
    /* Protocol members go here */
}

Любой протокол, наследовавшийся из протокола, это отмечено с class требование может аналогично быть принято только типами классов.

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

Можно использовать протоколы для объявления, какие методы делегат класса или структуры должен реализовать, как описано в Делегации.

Грамматика объявления протокола

объявление протокола → «атрибуты _{выбирает}, модификатор уровня доступа _{выбирает»}protocol«пункт наследования типа имени протокола _{выбирает} организация протокола»

имя протокола → идентификатор -

организация протокола → {«объявления элемента протокола _{выбирают»}}

объявление элемента протокола → объявление свойства протокола -

объявление элемента протокола → объявление метода протокола -

объявление элемента протокола → объявление инициализатора протокола -

объявление элемента протокола → нижнее объявление протокола -

объявление элемента протокола → связанное описание типа протокола -

объявления элемента протокола → «объявления элемента протокола объявления элемента протокола _{выбирают»}

Объявление свойства протокола

Протоколы объявляют, что приспосабливание типам должно реализовать свойство включением объявления свойства протокола в организации объявления протокола. Объявления свойства протокола имеют специальную форму объявления переменной:

```
var property name: type { get set }
```

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

Метод get и требования метода set могут быть удовлетворены соответствующим типом во множестве путей. Если объявление свойства включает обоих get и set ключевые слова, соответствующий тип может реализовать его с сохраненным переменным свойством или вычисленным свойством, которое и читаемо и writeable (т.е. тот, реализующий и метода get и метод set). Однако то объявление свойства не может быть реализовано как постоянное свойство или вычисленное свойство только для чтения. Если объявление свойства включает только get ключевое слово, это может быть реализовано как любой вид свойства. Для примеров приспосабливания типам, реализующим требования свойства протокола, посмотрите Требования Свойства.

См. также Объявление переменной.

Грамматика объявления свойства протокола

объявление свойства протокола → «объявление переменной возглавляет блок ключевого слова метода set метода get аннотации типа имени переменной»

Объявление метода протокола

Протоколы объявляют, что приспосабливание типам должно реализовать метод включением объявления метода протокола в организации объявления протокола. Объявления метода протокола имеют ту же форму как объявления функции за двумя исключениями: Они не включают тело функции, и Вы не можете обеспечить значения параметров по умолчанию как часть объявления функции. Для примеров приспосабливания типам, реализующим требования метода протокола, посмотрите Требования Метода.

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

См. также Объявление функции.

Грамматика объявления метода протокола

объявление метода протокола → «функциональное главное имя функции универсальный пункт параметра _{выбирает} функциональная подпись»

Объявление инициализатора протокола

Протоколы объявляют, что приспосабливание типам должно реализовать инициализатор включением объявления инициализатора протокола в организации объявления протокола. Объявления инициализатора протокола имеют ту же форму как объявления инициализатора, кроме они не включают организацию инициализатора.

Соответствующий тип может удовлетворить nonfailable требование инициализатора протокола путем реализации nonfailable инициализатора или init! failable инициализатор. Соответствующий тип может удовлетворить failable требование инициализатора протокола путем реализации любого вида инициализатора.

Когда класс реализует инициализатор для удовлетворения требования инициализатора протокола, инициализатор должен быть отмечен с required модификатор объявления, если класс уже не отмечен с final модификатор объявления.

См. также Объявление Инициализатора.

Грамматика объявления инициализатора протокола

объявление инициализатора протокола → «инициализатор возглавляет, универсальный пункт параметра _{выбирают} пункт параметра»

Объявление нижнего индекса протокола

Протоколы объявляют, что приспосабливание типам должно реализовать нижний индекс включением объявления нижнего индекса протокола в организации объявления протокола. Объявления нижнего индекса протокола имеют специальную форму нижнего объявления:

subscript (parameters) -> return type { get set }

Нижние объявления только объявляют минимального метода get и требования реализации метода set для типов, соответствующих протоколу. Если нижнее объявление включает обоих get и set ключевые слова, соответствующий тип должен реализовать и метода get и пункт метода set. Если нижнее объявление включает только get ключевое слово, соответствующий тип должен реализовать, по крайней мере, пункт метода get и дополнительно может реализовать пункт метода set.

См. также Нижнее Объявление.

Грамматика протокола преобразовывает объявление в нижний индекс

нижнее объявление протокола → «преобразовывает главный нижний блок ключевого слова метода set метода get результата в нижний индекс»

Протокол связанное описание типа

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

См. также Объявление альтернативного имени Типа.

Грамматика протокола связала описание типа

протокол связал описание типа → typealias-head-type-inheritance-clause-opt-typealias-assignment-opt-

Объявление инициализатора

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

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

Следующая форма объявляет инициализаторы для структур, перечислений и определяемых инициализаторов классов:

```
init(parameters) {
```
```
    statements
```
```
}
```

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

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

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

Для объявления инициализаторов удобства для класса отметьте объявление инициализатора с convenience модификатор объявления.

```
convenience init(parameters) {
```
```
    statements
```
```
}
```

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

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

По умолчанию инициализаторы, объявленные в суперклассе, не наследованы подклассами. Однако если подкласс инициализирует все свои сохраненные свойства со значениями по умолчанию и не определяет собственных инициализаторов, он наследовал все инициализаторы суперкласса. Если подкласс переопределяет все определяемые инициализаторы суперкласса, он наследовал инициализаторы удобства суперкласса.

Как с методами, свойствами и нижними индексами, необходимо отметить переопределенные определяемые инициализаторы с override модификатор объявления.

Для наблюдения примеров инициализаторов в различных описаниях типа посмотрите Инициализацию.

Инициализаторы Failable

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

Для объявления failable инициализатора, производящего дополнительный экземпляр добавьте вопросительный знак к init ключевое слово в объявлении инициализатора (init?). Для объявления failable инициализатора, производящего неявно развернутый дополнительный экземпляр добавьте восклицательный знак вместо этого (init!). Пример ниже шоу init? failable инициализатор, производящий дополнительный экземпляр структуры.

      struct SomeStruct {
    let string: String
    // produces an optional instance of 'SomeStruct'
    init?(input: String) {
        if input.isEmpty {
            // discard 'self' and return 'nil'
            return nil
        }
        string = input
    }
}




  

Вы вызываете init? failable инициализатор таким же образом, что Вы вызываете nonfailable инициализатор, за исключением того, что необходимо иметь дело с возможностями результата.

      if let actualInstance = SomeStruct(input: "Hello") {
    // do something with the instance of 'SomeStruct'
} else {
    // initialization of 'SomeStruct' failed and the initializer returned 'nil'
}

failable инициализатор структуры или перечисления может возвратиться nil в любой точке в реализации организации инициализатора. failable инициализатор класса, однако, может возвратиться nil только после того, как все сохраненные свойства того класса инициализируются и self.init или super.init вызывается (т.е. любая делегация инициализатора выполняется).

failable инициализатор может делегировать к любому виду инициализатора. nonfailable инициализатор может делегировать к другому nonfailable инициализатору или к init! failable инициализатор.

Отказ в инициализации распространяет через делегацию инициализатора. В частности, если failable инициализатор делегирует к инициализатору, переставшему работать и возвращающемуся nil, тогда инициализатор, делегировавший также сбои и неявно возвращающийся nil. Если nonfailable инициализатор делегирует к init! failable инициализатор, переставший работать и возвращающийся nil, тогда ошибка периода выполнения повышена (как будто Вы использовали ! оператор для разворачивания дополнительного, имеющего a nil значение).

failable определяемый инициализатор может быть переопределен в подклассе любым видом определяемого инициализатора. nonfailable определяемый инициализатор может быть переопределен в подклассе nonfailable определяемым инициализатором только.

Для получения дополнительной информации и видеть примеры failable инициализаторов, см. Инициализаторы Failable.

Грамматика объявления инициализатора

объявление инициализатора → «инициализатор возглавляет, универсальный пункт параметра _{выбирают} организация инициализатора пункта параметра»

голова инициализатора → «атрибуты _{выбирает}, модификаторы объявления _{выбирают»}init

голова инициализатора → «атрибуты _{выбирает}, модификаторы объявления _{выбирают»}init?

голова инициализатора → «атрибуты _{выбирает}, модификаторы объявления _{выбирают»}init!

организация инициализатора → блок кода -

Объявление Deinitializer

deinitializer объявление объявляет deinitializer для типа класса. Deinitializers не берут параметров и имеют следующую форму:

```
deinit {
```
```
    statements
```
```
}
```

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

Подкласс наследовал deinitializer своего суперкласса, который неявно вызывают непосредственно перед тем, как объект подкласса освобожден. Объект подкласса не освобожден, пока все deinitializers в его цепочке наследования не закончили выполняться.

Deinitializers не вызывают непосредственно.

Для примера того, как использовать deinitializer в объявлении класса, посмотрите Deinitialization.

Грамматика deinitializer объявления

deinitializer-объявление → «атрибуты _{выбирает»}deinitблок кода -

Объявление расширения

Объявление расширения позволяет Вам расширять поведение существующего класса, структуры и типов перечисления. Объявления расширения объявляются с помощью ключевого слова extension и имейте следующую форму:

extension type name: adopted protocols {

```
    declarations
```
```
}
```

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

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

Свойства, методы и инициализаторы существующего типа не могут быть переопределены в расширении того типа.

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

Грамматика объявления расширения

объявление расширения → «модификатор уровня доступа _{выбирает»}extension«пункт наследования типа идентификатора типа _{выбирает} дополнительная организация»

дополнительная организация → {«объявления _{выбирают»}}

Нижнее объявление

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

```
subscript (parameters) -> return type {
```
```
    get {
```
```
        statements
```
```
    }
```
```
    set(setter name) {
```
```
        statements
```
```
    }
```
```
}
```

Нижние объявления могут появиться только в контексте класса, структуры, перечисления, расширения или объявления протокола.

Параметры указывают, что один или несколько индексов раньше получали доступ к элементам соответствующего типа в нижнем выражении (например, i в выражении object[i]). Несмотря на то, что индексы, используемые для доступа к элементам, могут иметь любой тип, каждый параметр должен включать аннотацию типа для указания типа каждого индекса. Тип возврата указывает тип получаемого доступ элемента.

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

Имя метода set и круглые скобки включения являются дополнительными. При обеспечении имени метода set оно используется в качестве имени параметра к методу set. Если Вы не обеспечиваете имя метода set, название параметра по умолчанию к методу set value. Тип имени метода set должен совпасть с типом возврата.

Можно перегрузить нижнее объявление в типе, в котором оно объявляется, пока параметры или тип возврата отличаются от того, Вы перегружаетесь. Можно также переопределить нижнее объявление, наследованное от суперкласса. Когда Вы делаете так, необходимо отметить переопределенное нижнее объявление с override модификатор объявления.

Можно также объявить нижние индексы в контексте объявления протокола, как описано в Объявлении Нижнего индекса Протокола.

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

Грамматика нижнего объявления

нижнее объявление → «преобразовывает главный нижний блок кода результата в нижний индекс»

нижнее объявление → «преобразовывает главный нижний блок метода set метода get результата в нижний индекс»

нижнее объявление → «преобразовывает главный нижний блок ключевого слова метода set метода get результата в нижний индекс»

нижняя голова → «атрибуты _{выбирает}, модификаторы объявления _{выбирают»}subscriptпункт параметра -

нижний результат → ->«атрибуты _{выбирают} тип»

Объявление оператора

Объявление оператора представляет новый инфикс, префикс или постфиксный оператор в Вашу программу и объявляется с помощью ключевого слова operator.

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

Существует три канонических формы объявления оператора, один для каждой неподвижности. Неподвижность оператора указана путем маркировки объявления оператора с infix, prefix, или postfix модификатор объявления перед operator ключевое слово. В каждой форме имя оператора может содержать только символы оператора, определенные в Операторах.

Следующая форма объявляет новый инфиксный оператор:

```
infix operator operator name {
```
```
    precedence precedence level
```
```
    associativity associativity
```
```
}
```

Инфиксный оператор является бинарным оператором, записанным между его двумя операндами, такими как знакомый оператор сложения (+) в выражении 1 + 2.

Инфиксные операторы могут дополнительно указать приоритет, ассоциативность или обоих.

Приоритет оператора указывает, как плотно оператор связывает с его операндами в отсутствие группирующихся круглых скобок. Вы указываете приоритет оператора путем записи контекстно-зависимого ключевого слова precedence сопровождаемый уровнем приоритета. Уровень приоритета может быть любым целым числом (десятичное целое число) от 0 до 255; в отличие от десятичных целочисленных литералов, это не может содержать символы подчеркивания. Несмотря на то, что уровень приоритета является определенным числом, это значительно только относительно другого оператора. Т.е. когда два оператора конкурируют друг с другом для их операндов, такой как в выражении 2 + 3 * 5, оператор с более высоким уровнем приоритета связывает более плотно с его операндами.

Ассоциативность оператора указывает, как последовательность операторов с тем же уровнем приоритета группируется в отсутствие группирующихся круглых скобок. Вы указываете ассоциативность оператора путем записи контекстно-зависимого ключевого слова associativity сопровождаемый ассоциативностью, которая является одним из контекстно-зависимых ключевых слов left, right, или none. Операторы, которые являются левоассоциативной группой слева направо. Например, оператор вычитания (-) левоассоциативно, и поэтому выражение 4 - 5 - 6 сгруппирован как (4 - 5) - 6 и оценивает к -7. Операторы, которые являются правоассоциативной группой справа налево и операторами, указанными с ассоциативностью none не связывайтесь вообще. Неассоциативные операторы того же уровня приоритета не могут казаться смежными с каждым к другому. Например, 1 < 2 < 3 не допустимое выражение.

Инфиксные операторы, объявляющиеся, не указывая приоритет или ассоциативность, инициализируются с уровнем приоритета 100 и ассоциативностью none.

Следующая форма объявляет новый префиксный оператор:

```
prefix operator operator name {}
```

Префиксный оператор является унарным оператором, сразу записанным перед его операндом, таким как префиксный инкрементный оператор (++) находится в выражении ++i.

Объявления префиксных операторов не указывают уровень приоритета. Префиксные операторы неассоциативны.

Следующая форма объявляет новый постфиксный оператор:

```
postfix operator operator name {}
```

Постфиксный оператор является унарным оператором, сразу записанным после его операнда, такого как постфиксный инкрементный оператор (++) находится в выражении i++.

Как с префиксными операторами, объявления постфиксного оператора не указывают уровень приоритета. Постфиксные операторы неассоциативны.

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

Грамматика объявления оператора

объявление оператора → объявление префиксного оператора - объявление постфиксного оператора - объявление инфиксного оператора -

объявление префиксного оператора → prefixoperatorоператор -{}

объявление постфиксного оператора → postfixoperatorоператор -{}

объявление инфиксного оператора → infixoperatorоператор -{«атрибуты инфиксного оператора _{выбирают»}}

атрибуты инфиксного оператора → «пункт приоритета _{выбирают}, пункт ассоциативности _{выбирает»}

пункт приоритета → precedenceуровень приоритета -

уровень приоритета → десятичное целое число между 0 и 255, включительно

пункт ассоциативности → associativityассоциативность -

ассоциативность → left right none

Модификаторы объявления

Модификаторы объявления являются ключевыми словами или контекстно-зависимыми ключевыми словами, изменяющими поведение или значение объявления. Вы указываете модификатор объявления путем записи надлежащего ключевого слова или контекстно-зависимого ключевого слова между атрибутами объявления (если таковые имеются) и ключевого слова, представляющего объявление.

dynamic

Примените этот модификатор к любому элементу класса, который может быть представлен Objective C. Когда Вы отмечаете объявление элемента с dynamic модификатор, доступ к тому элементу всегда динамично диспетчеризируется с помощью времени выполнения Objective C. Доступ к тому элементу никогда не встраивается или devirtualized компилятором.

Поскольку объявления, отмеченные с dynamic модификатор диспетчеризируется с помощью времени выполнения Objective C, они неявно отмечены с objc атрибут.

final

Примените этот модификатор к классу или к свойству, методу, или преобразуйте элемент в нижний индекс класса. Это применилось к классу, чтобы указать, что класс не может быть разделен на подклассы. Это применилось к свойству, методу или нижнему индексу класса, чтобы указать, что элемент класса не может быть переопределен ни в каком подклассе.

lazy

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

optional

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

Можно применяться optional модификатор только к протоколам, отмеченным с objc атрибут. В результате только типы классов могут принять и соответствовать протоколу, содержащему требования необязательного элемента. Для получения дополнительной информации о том, как использовать optional модификатор и для руководства о том, как получить доступ к дополнительным элементам протокола — например, когда Вы не уверены, реализует ли соответствующий тип их — видит Дополнительные Требования Протокола.

required: Примените этот модификатор к определяемому или инициализатору удобства класса, чтобы указать, что каждый подкласс должен реализовать тот инициализатор. Реализация подкласса того инициализатора должна также быть отмечена с required модификатор.
weak: weak модификатор применяется к переменной или сохраненному переменному свойству, чтобы указать, что переменная или свойство имеют слабую ссылку на объект, хранивший как его значение. Тип переменной или свойства должен быть дополнительным типом класса. Используйте weak модификатор для предотвращения циклов сильной ссылки. Для примера и большей информации о weak модификатор, посмотрите Слабые ссылки.

Уровни управления доступом

Swift обеспечивает три уровня управления доступом: общедоступный, внутренний, и частный. Можно отметить объявление с одним из модификаторов уровня доступа ниже для указания уровня доступа объявления. Управление доступом обсуждено подробно в Управлении доступом.

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

Каждый модификатор уровня доступа выше дополнительно принимает отдельный аргумент, состоящий из ключевого слова set включенный в круглые скобки (например, private(set)). Используйте эту форму модификатора уровня доступа, когда Вы хотите указать уровень доступа для метода set переменной или нижнего индекса, это меньше чем или равно уровню доступа переменной, или преобразуйте себя в нижний индекс, как обсуждено в Методах get и Методах set.

Грамматика модификатора объявления

модификатор объявления → class convenience dynamic final infix lazy mutating nonmutating optional override postfix prefix required static unowned unowned(safe) unowned(unsafe) weak

модификатор объявления → модификатор уровня доступа -

модификаторы объявления → «модификаторы объявления модификатора объявления _{выбирают»}

модификатор уровня доступа → internal internal(set)

модификатор уровня доступа → private private(set)

модификатор уровня доступа → public public(set)

модификаторы уровня доступа → «модификаторы уровня доступа модификатора уровня доступа _{выбирают»}

Операторы

Атрибуты