Swift язык программирования: основы

Swift является новым языком программирования для разработки приложений OS X и iOS. Тем не менее, много частей Swift будут знакомы от Вашего опыта разработки в C и Objective C.

Swift обеспечивает свои собственные версии всего основного принципа C и типов Objective C, включая Int для целых чисел, Double и Float для значений с плавающей точкой, Bool для булевых значений, и String для текстовых данных. Swift также обеспечивает мощные версии двух основных типов набора, Array и Dictionary, как описано в Типах Набора.

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

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

Swift также представляет дополнительные типы, обрабатывающие отсутствие значения. Optionals заявляют или “существует значение, и оно равняется x” или “нет значения вообще”. Optionals подобны использованию nil с указателями в Objective C, но они работают на любой тип, не просто классы. Optionals более безопасны и более выразительны, чем nil указатели в Objective C и в основе многих наиболее мощных функций Swift.

Optionals являются примером факта, что Swift является безопасным с точки зрения типов языком. Swift помогает Вам согласиться с типами значений, с которыми может работать Ваш код. Если часть Вашего кода ожидает a String, безопасность типов препятствует тому, чтобы Вы передали его Int по ошибке. Это ограничение позволяет Вам поймать и фиксировать ошибки как можно раньше в процессе разработки.

Константы и переменные

Константы и переменные связывают имя (такой как maximumNumberOfLoginAttempts или welcomeMessage) со значением определенного типа (такого как число 10 или строка "Hello"). Значение константы не может быть изменено, как только оно установлено, тогда как переменная может быть установлена в различное значение в будущем.

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

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

      let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

Этот код может быть считан как:

“Объявите новую вызванную константу maximumNumberOfLoginAttempts, и дайте ему значение 10. Затем объявите новую вызванную переменную currentLoginAttempt, и дайте ему начальное значение 0.”

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

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

      var x = 0.0, y = 0.0, z = 0.0

Введите аннотации

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

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

      var welcomeMessage: String

Двоеточие в средних значениях объявления “… типа …”, таким образом, код выше может быть считан как:

“Объявите вызванную переменную welcomeMessage это имеет тип String.”

Фраза “типа String” означает, “может сохранить любого String значение”. Думайте о нем как о значении “типа вещи” (или “вид вещи”), который может быть сохранен.

welcomeMessage переменная может теперь быть установлена в любое строковое значение без ошибки:

welcomeMessage = "Hello"

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

      var red, green, blue: Double

Примечание:

Редко, чтобы Вы записали аннотации типа на практике. При обеспечении начального значения для константы или переменный в точке, что это определяется, Swift может почти всегда выводить тип, который будет использоваться для той константы или переменный, как описано в Безопасности с точки зрения типов и Выводе типа. В welcomeMessage пример выше, никакое начальное значение не предоставлено, и таким образом, тип welcomeMessage переменная указана с аннотацией типа вместо того, чтобы быть выведенной из начального значения.

Именование констант и переменных

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

      let π = 3.14159
let 你好 = "你好世界"
let    = "dogcow"

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

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

Можно изменить значение существующей переменной к другому значению совместимого типа. В этом примере, значении friendlyWelcome изменяется от "Hello!" к "Bonjour!":

      var friendlyWelcome = "Hello!"
friendlyWelcome = "Bonjour!"
// friendlyWelcome is now "Bonjour!"

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

      let languageName = "Swift"
languageName = "Swift++"
// this is a compile-time error - languageName cannot be changed

Печать констант и переменных

Можно распечатать текущую стоимость константы или переменный с println функция:

      println(friendlyWelcome)
// prints "Bonjour!"

println глобальная функция, распечатывающая значение, сопровождаемое разрывом строки, к надлежащему выводу. В XCode, например, println распечатывает его вывод в «консольной» области XCode. (Вторая функция, print, выполняет ту же задачу, не добавляя разрыв строки до конца значения, которое будет распечатано.)

println функционируйте распечатывает любого String оцените Вас, передают ему:

      println("This is a string")
// prints "This is a string"

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

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

      println("The current value of friendlyWelcome is \(friendlyWelcome)")
// prints "The current value of friendlyWelcome is Bonjour!"

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

Комментарии в Swift очень подобны комментариям в C. Однострочные комментарии начинаются с двух наклонных черт вправо (//):

// this is a comment

Многострочные комментарии запускаются с наклонной черты вправо, сопровождаемой звездочкой (/*) и конец со звездочкой, сопровождаемой наклонной чертой вправо (*/):

      /* this is also a comment,
but written over multiple lines */

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

      /* this is the start of the first multiline comment
/* this is the second, nested multiline comment */
this is the end of the first multiline comment */

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

Точки с запятой

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

      let cat = " "; println(cat)
// prints " "

Целые числа

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

Swift обеспечивает целые числа со знаком и целых без знака в 8, 16, 32, и формы на 64 бита. Эти целые числа следуют соглашению о присвоении имен, подобному C в этом, 8-разрядное целое без знака имеет тип UInt8, и 32-разрядное целое число со знаком имеет тип Int32. Как все типы в Swift, эти целые типы капитализировали имена.

Целочисленные границы

Можно получить доступ к минимальным и максимальным значениям каждого целого типа с min и max свойства:

      let minValue = UInt8.min  // minValue is equal to 0, and is of type UInt8
let maxValue = UInt8.max  // maxValue is equal to 255, and is of type UInt8

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

Интервал

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

На 32-разрядной платформе, Int тот же размер как Int32.
На 64-разрядной платформе, Int тот же размер как Int64.

Если Вы не должны работать с определенным размером целого числа, всегда используйте Int для целочисленных значений в Вашем коде. Это помогает непротиворечивости кода и функциональной совместимости. Даже на 32-разрядных платформах, Int может сохранить любое значение между -2,147,483,648 и 2,147,483,647, и является достаточно большим для многих целочисленных диапазонов.

UInt

Swift также обеспечивает тип целого без знака, UInt, который имеет тот же размер как собственный размер слова текущей платформы:

На 32-разрядной платформе, UInt тот же размер как UInt32.
На 64-разрядной платформе, UInt тот же размер как UInt64.

Примечание:

Использовать UInt только, когда Вам в частности нужен тип целого без знака с тем же размером как собственный размер слова платформы. Если дело обстоит не так, Int предпочтен, даже когда значения, которые будут сохранены, как известно, являются неотрицательными. Непротиворечивое использование Int для функциональной совместимости кода пособий целочисленных значений, избегает потребности преобразовать между различными типами числа и соответствует вывод целого типа, как описано в Безопасности с точки зрения типов и Выводе типа.

Числа с плавающей точкой

Числа с плавающей точкой являются числами с дробным компонентом, такой как 3.14159, 0.1, и -273.15.

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

Double представляет 64-разрядное число с плавающей точкой.
Float представляет 32-разрядное число с плавающей точкой.

Безопасность с точки зрения типов и вывод типа

Swift является безопасным с точки зрения типов языком. Безопасный с точки зрения типов язык призывает Вас соглашаться с типами значений, с которыми может работать Ваш код. Если часть Вашего кода ожидает a String, Вы не можете передать его Int по ошибке.

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

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

Из-за вывода типа Swift требует гораздо меньшего количества описаний типа, чем языки, такие как C или Objective C. Константы и переменные все еще явно вводятся, но большая часть работы указания их типа выполнена для Вас.

Когда Вы объявляете константу или переменный с начальным значением, вывод типа особенно полезен. Это часто делается путем присвоения литерального значения (или литерал) к константе или переменный в точке, что Вы объявляете его. (Литеральное значение является значением, появляющимся непосредственно в Вашем исходном коде, такой как 42 и 3.14159 в примерах ниже.)

Например, если Вы присваиваете литеральное значение 42 к новой константе, не говоря то, что вводит его, Swift выводит, что Вы хотите, чтобы константа была Int, потому что Вы инициализировали его с числом, которое похоже на целое число:

      let meaningOfLife = 42
// meaningOfLife is inferred to be of type Int

Аналогично, если Вы не указываете тип для литерала с плавающей точкой, Swift выводит, что Вы хотите создать a Double:

      let pi = 3.14159
// pi is inferred to be of type Double

Swift всегда выбирает Double (а не Float) при выведении типа чисел с плавающей точкой.

Если Вы комбинируете целочисленные и литералы с плавающей точкой в выражении, типе Double будет выведен из контекста:

      let anotherPi = 3 + 0.14159
// anotherPi is also inferred to be of type Double

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

Числовые литералы

Целочисленные литералы могут быть записаны как:

Десятичное число, без префикса
Двоичное число, с a 0b префикс
Восьмеричное число, с a 0o префикс
Шестнадцатеричное число, с a 0x префикс

Все эти целочисленные литералы имеют десятичное значение 17:

      let decimalInteger = 17
let binaryInteger = 0b10001       // 17 in binary notation
let octalInteger = 0o21           // 17 in octal notation
let hexadecimalInteger = 0x11     // 17 in hexadecimal notation

Литералы с плавающей точкой могут быть десятичными (без префикса) или шестнадцатеричными (с a 0x префикс). У них должны всегда быть число (или шестнадцатеричное число) с обеих сторон десятичной точки. У них может также быть дополнительная экспонента, обозначенная верхним регистром или нижним регистром e для десятичных плаваний, или верхнего регистра или нижнего регистра p для шестнадцатеричных плаваний.

Для десятичных чисел с экспонентой exp, основание системы счисления умножается на ^10exp:

1.25e2 средние значения 1,25 ^{× 102}, или 125.0.
1.25e-2 средние значения 1,25 × ^10-2, или 0.0125.

Для шестнадцатеричных чисел с экспонентой exp, основание системы счисления умножается на ^2exp:

0xFp2 средние значения 15 ^{× 22}, или 60.0.
0xFp-2 средние значения 15 × ^2-2, или 3.75.

Все эти литералы с плавающей точкой имеют десятичное значение 12.1875:

      let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

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

      let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1

Числовое преобразование типов

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

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

Целочисленное преобразование

Диапазон чисел, которые могут быть сохранены в целочисленной константе или переменные, отличается для каждого числового типа. Int8 постоянный или переменный может сохранить числа между -128 и 127, тогда как a UInt8 постоянный или переменный может сохранить числа между 0 и 255. О числе, которое не впишется в константу или переменную размерного целого типа, сообщают как ошибка, когда компилируется Ваш код:

      let cannotBeNegative: UInt8 = -1
// UInt8 cannot store negative numbers, and so this will report an error
let tooBig: Int8 = Int8.max + 1
// Int8 cannot store a number larger than its maximum value,
// and so this will also report an error

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

Для преобразования одного определенного типа числа в другого Вы инициализируете новое число желаемого типа с существующим значением. В примере ниже, константа twoThousand имеет тип UInt16, тогда как константа one имеет тип UInt8. Они не могут быть добавлены вместе непосредственно, потому что они не имеют того же типа. Вместо этого этот пример вызовы UInt16(one) создать новое UInt16 инициализированный со значением one, и использование это значение вместо оригинала:

      let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)

Поскольку обе стороны дополнения имеют теперь тип UInt16, дополнение позволяется. Постоянный вывод (twoThousandAndOne) выведен, чтобы иметь тип UInt16, потому что это - сумма два UInt16 значения.

SomeType(ofInitialValue) способ по умолчанию вызвать инициализатор типа Swift и передать в начальном значении. Негласно, UInt16 имеет инициализатор, принимающий a UInt8 значение, и таким образом, этот инициализатор используется для создания нового UInt16 от существующего UInt8. Вы не можете передать ни в каком типе сюда, однако — это должен быть тип для который UInt16 обеспечивает инициализатор. При расширении существующих типов для обеспечения принимающих инициализаторов новые типы (включая собственные определения типа) покрыты Расширениями.

Целочисленное и преобразование с плавающей точкой

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

      let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
// pi equals 3.14159, and is inferred to be of type Double

Здесь, значение константы three используется для создания новой ценности типа Double, так, чтобы обе стороны дополнения имели тот же тип. Без этого преобразования на месте, не было бы позволено дополнение.

С плавающей точкой к целочисленному преобразованию должен также быть сделан явным. Целый тип может быть инициализирован с a Double или Float значение:

      let integerPi = Int(pi)
// integerPi equals 3, and is inferred to be of type Int

Значения с плавающей точкой являются всегда усеченными, когда используется инициализировать новое целочисленное значение таким образом. Это означает это 4.75 становится 4, и -3.9 становится -3.

Введите псевдонимы

Псевдонимы типа определяют альтернативное имя для существующего типа. Вы определяете псевдонимы типа с помощью typealias ключевое слово.

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

      typealias AudioSample = UInt16

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

      var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound is now 0

Здесь, AudioSample определяется как псевдоним для UInt16. Поскольку это - псевдоним, вызов к AudioSample.min фактически вызовы UInt16.min, который обеспечивает начальное значение 0 для maxAmplitudeFound переменная.

Булевские переменные

Swift имеет основной булев тип, вызванный Bool. Булевы значения упоминаются как логичные, потому что они могут только когда-либо быть истиной или ложью. Swift обеспечивает два булевых постоянных значения, true и false:

      let orangesAreOrange = true
let turnipsAreDelicious = false

Типы orangesAreOrange и turnipsAreDelicious были выведены как Bool от факта, что они были инициализированы с булевыми литеральными значениями. Как с Int и Double выше, Вы не должны объявлять константы или переменные как Bool если Вы устанавливаете их в true или false как только Вы создаете их. Вывод типа помогает сделать Код SWIFT более кратким и читаемым, когда это инициализирует константы или переменные с другими значениями, тип которых уже известен.

Когда Вы работаете с условными операторами такой как, булевы значения особенно полезны if оператор:

      if turnipsAreDelicious {
    println("Mmm, tasty turnips!")
} else {
    println("Eww, turnips are horrible.")
}
// prints "Eww, turnips are horrible."

Условные операторы такой как if оператор покрыт более подробно в Потоке управления.

Безопасность типов Swift препятствует тому, чтобы небулевы значения были заменены Bool. Следующий пример сообщает об ошибке времени компиляции:

      let i = 1
if i {
    // this example will not compile, and will report an error
}

Однако альтернативный пример ниже допустим:

      let i = 1
if i == 1 {
    // this example will compile successfully
}

Результат i == 1 сравнение имеет тип Bool, и таким образом, этот второй пример передает проверку типа. Сравнения как i == 1 обсуждены в Основных Операторах.

Как с другими примерами безопасности типов в Swift, этот подход избегает случайных ошибок и гарантирует, что намерение определенного раздела кода всегда ясно.

Кортежи

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

В этом примере, (404, "Not Found") кортеж, описывающий Код состояния HTTP. Код состояния HTTP является специальным значением, возвращенным веб-сервером каждый раз, когда Вы запрашиваете веб-страницу. Код состояния 404 Not Found возвращается, если Вы запрашиваете не существующую веб-страницу.

      let http404Error = (404, "Not Found")
// http404Error is of type (Int, String), and equals (404, "Not Found")

(404, "Not Found") кортеж группируется Int и a String дать Коду состояния HTTP два отдельных значения: число и человекочитаемое описание. Это может быть описано как “кортеж типа (Int, String)”.

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

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

      let (statusCode, statusMessage) = http404Error
println("The status code is \(statusCode)")
// prints "The status code is 404"
println("The status message is \(statusMessage)")
// prints "The status message is Not Found"

Если Вы только нуждаетесь в некоторых значениях кортежа, игнорируете части кортежа с подчеркиванием (_) когда Вы анализируете кортеж:

      let (justTheStatusCode, _) = http404Error
println("The status code is \(justTheStatusCode)")
// prints "The status code is 404"

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

      println("The status code is \(http404Error.0)")
// prints "The status code is 404"
println("The status message is \(http404Error.1)")
// prints "The status message is Not Found"

Когда кортеж определяется, можно назвать отдельные элементы в кортеже:

      let http200Status = (statusCode: 200, description: "OK")

При именовании элементов в кортеже можно использовать имена элементов для доступа к значениям тех элементов:

      println("The status code is \(http200Status.statusCode)")
// prints "The status code is 200"
println("The status message is \(http200Status.description)")
// prints "The status message is OK"

Кортежи особенно полезны как возвращаемые значения функций. Функция, пытающаяся получить веб-страницу, могла бы возвратиться (Int, String) тип «кортеж» для описания успешности или неуспешности извлечения страницы. Путем возврата кортежа с двумя отличными значениями, каждым другим типом, функция предоставляет более полезную информацию о своем результате, чем если бы это могло бы только возвратить единственное значение единственного типа. Для получения дополнительной информации посмотрите Функции с Многократными Возвращаемыми значениями.

Optionals

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

Существует значение, и оно равняется x

или

Нет значения вообще

Примечание:

Понятие optionals не существует в C или Objective C. Самой близкой вещью в Objective C является возможность возвратиться nil от метода, который иначе возвратил бы объект, с nil значение “отсутствия доступного объекта”. Однако это только работает на объекты — это не работает на структуры, основные типы C или перечислимые величины. Для этих типов методы Objective C обычно возвращают специальное значение (такой как NSNotFound) указать отсутствие значения. Этот подход предполагает, что вызывающая сторона метода знает, что существует специальное значение для тестирования против и не забывает проверять на него. optionals Swift позволяют Вам указать отсутствие значения для любого типа вообще без потребности в специальных константах.

Вот пример того, как optionals может использоваться для разрешения с отсутствием значения. Swift String типу вызвали метод toInt, который пытается преобразовать a String значение в Int значение. Однако не каждая строка может быть преобразована в целое число. Строка "123" может быть преобразован в числовое значение 123, но строка "hello, world" не имеет очевидного числового значения для преобразования в.

Пример ниже использует toInt() метод, чтобы попытаться преобразовать a String в Int:

      let possibleNumber = "123"
let convertedNumber = possibleNumber.toInt()
// convertedNumber is inferred to be of type "Int?", or "optional Int"

Поскольку toInt() метод мог бы перестать работать, он возвращает дополнительное Int, вместо Int. Дополнительное Int записан как Int?, нет Int. Вопросительный знак указывает, что значение, которое он содержит, является дополнительным, означая, что он мог бы содержать некоторых Int значение, или это не могло бы содержать значение вообще. (Это не может содержать ничто больше, такое как a Bool значение или a String значение. Это любой Int, или это - ничто вообще.)

ноль

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

      var serverResponseCode: Int? = 404
// serverResponseCode contains an actual Int value of 404
serverResponseCode = nil
// serverResponseCode now contains no value

При определении дополнительной переменной, не обеспечивая значение по умолчанию переменная автоматически установлена в nil для Вас:

      var surveyAnswer: String?
// surveyAnswer is automatically set to nil

Если операторы и принудительное разворачивание

Можно использовать if оператор, чтобы узнать, содержит ли дополнительное значение путем сравнения дополнительного с nil. Вы выполняете это сравнение с “равный” оператору (==) или “не равняются” оператору (!=).

Если дополнительное имеет значение, это считается “не равным” nil:

      if convertedNumber != nil {
    println("convertedNumber contains some integer value.")
}
// prints "convertedNumber contains some integer value."

Как только Вы уверены, что дополнительное действительно содержит значение, можно получить доступ к его базовому значению путем добавления восклицательного знака (!) до конца имени optional. Восклицательный знак эффективно говорит, “Я знаю, что это дополнительное определенно имеет значение; используйте его”. Это известно как принудительное разворачивание значения optional:

      if convertedNumber != nil {
    println("convertedNumber has an integer value of \(convertedNumber!).")
}
// prints "convertedNumber has an integer value of 123."

Для больше на if оператор, посмотрите Поток управления.

Дополнительная привязка

Вы используете дополнительную привязку, чтобы узнать, содержит ли дополнительное значение, и если так, для предоставления доступа к тому значению доступным как временная константа или переменным. Дополнительная привязка может использоваться с if и while операторы, чтобы проверить на значение в дополнительном, и извлечь то значение в константу или переменный, как часть единственного действия. if и while операторы описаны более подробно в Потоке управления.

Запишите дополнительную привязку для if оператор следующим образом:

```
if let constantName = someOptional {
```
```
    statements
```
```
}
```

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

      if let actualNumber = possibleNumber.toInt() {
    println("\'\(possibleNumber)\' has an integer value of \(actualNumber)")
} else {
    println("\'\(possibleNumber)\' could not be converted to an integer")
}
// prints "'123' has an integer value of 123"

Этот код может быть считан как:

“Если дополнительное Int возвращенный possibleNumber.toInt содержит значение, установите новую вызванную константу actualNumber к значению, содержавшемуся в дополнительном”.

Если преобразование успешно, actualNumber постоянный становится доступным для использования в первом ответвлении if оператор. Это было уже инициализировано со значением, содержавшим в дополнительном, и таким образом, нет никакой потребности использовать ! снабдите суффиксом для доступа к его значению. В этом примере, actualNumber просто используется для печати результата преобразования.

Можно использовать и константы и переменные с дополнительной привязкой. Если Вы хотели управлять значением actualNumber в первом ответвлении if оператор, Вы могли записать if var actualNumber вместо этого, и значение, содержавшее в дополнительном, было бы сделано доступным как переменная, а не константа.

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

if let constantName = someOptional, anotherConstantName = someOtherOptional {

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

Неявно развернутый Optionals

Как описано выше, optionals указывают, что константе или переменный позволяют не иметь “никакого значения”. С Optionals можно согласовать if оператор, чтобы видеть, существует ли значение и может быть условно развернуто с дополнительной привязкой для доступа к значению optional, если это действительно существует.

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

Эти виды optionals определяются, как неявно развернуто optionals. Вы пишете неявно развернутый дополнительный путем размещения восклицательного знака (String!) вместо вопросительного знака (String?) после типа, который Вы хотите сделать дополнительным.

Неявно развернутые optionals полезны, когда значение optional подтверждено для существования сразу после того, как дополнительное сначала определяется и, как может определенно предполагаться, существует в каждой точке после того. Основное использование неявно развернутого optionals в Swift во время инициализации класса, как описано в Ненаходящихся в собственности Ссылках и Неявно Развернутых Дополнительных Свойствах.

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

      let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // requires an exclamation mark
 
let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // no need for an exclamation mark

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

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

      if assumedString != nil {
    println(assumedString)
}
// prints "An implicitly unwrapped optional string."

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

      if let definiteString = assumedString {
    println(definiteString)
}
// prints "An implicitly unwrapped optional string."

Утверждения

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

Отладка с утверждениями

Утверждение является проверкой на этапе выполнения, к которой определенно оценивает логическое условие true. Буквально помещенный, утверждение «утверждает», что условие является истиной. Вы используете утверждение, чтобы удостовериться, что существенное условие удовлетворено прежде, чем выполнить дальнейший код. Если условие оценивает к true, выполнение кода продолжается, как обычно; если условие оценивает к false, концы выполнения кода и Ваше приложение завершаются.

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

Вы пишете утверждение путем вызова глобальной переменной assert функция. Вы передаете assert функционируйте выражение, оценивающее к true или false и сообщение, которое должно быть выведено на экран, если результат условия false:

      let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// this causes the assertion to trigger, because age is not >= 0

В этом примере выполнение кода будет продолжаться только если age >= 0 оценивает к true, т.е. если значение age является неотрицательным. Если значение age отрицательно, как в коде выше, тогда age >= 0 оценивает к false, и утверждение инициировано, завершив приложение.

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

      assert(age >= 0)

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

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

Целочисленный нижний индекс передается пользовательской нижней реализации, но нижнее индексное значение могло быть слишком низким или слишком высоким.
Значение передается функции, но недопустимое значение означает, что функция не может выполнить свою задачу.
Дополнительное значение в настоящее время nil, но не -nil значение важно для последующего кода для выполнения успешно.

См. также Нижние индексы и Функции.

Основы

Константы и переменные

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

Введите аннотации

Именование констант и переменных

Печать констант и переменных

Комментарии

Точки с запятой

Целые числа

Целочисленные границы

Интервал

UInt

Числа с плавающей точкой

Безопасность с точки зрения типов и вывод типа

Числовые литералы

Числовое преобразование типов

Целочисленное преобразование

Целочисленное и преобразование с плавающей точкой

Введите псевдонимы

Булевские переменные

Кортежи

Optionals

ноль

Если операторы и принудительное разворачивание

Дополнительная привязка

Неявно развернутый Optionals

Утверждения

Отладка с утверждениями

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