The Swift programming language. Перевод. Глава 1

Основы.

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

В Swift представленны свои версии всех основных типов данных C и Objective-C, включая Int для целых; Double и Float для значений с плавающей запятой (дробных); Bool для булевых значений; и String для текстовых данных. В Swift так же представленны усовершенствованные версии двух основных сборных типов, Array и Dictionary, как описывается в collection types.

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

В дополнение к знакомым типам, Swift предлагает новые типы данных, которых не было в Objective-C. Это тип tuples, который дает возможность хранить группы значеий. Например tuples может вернуть несколько значений из функции в одной переменной(одно сборное значение).

В Swift так же представлены типы optionals, в которых можно хранить отсутствие значения(null, nul). По другому описать optionals можно так: «есть переменная и она равна x» или «переменная не содержит вообще никаких значений». Optionals похожи на использование nil с указателями в Objective-C, но они работают для любых типов, а не только для классов. Optionals безопастнее и выразительнее чем nil с указателями в Objective-C и являются основой многих мощных функций Swift.

Optionals является примером того, что Swift язык со строгой типизацией данных. Программируя на Swift, вы всегда точно знаете какой тип данных хранит переменная. Например если какая-то переменная у вас в коде хранит строку, вы не сможете присвоить ее значение переменной хранящей Int(целые). Это позволяет находить и исправлять ошибки намного раньше в процессе разработки.

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

Константы и пременные объявляются в Swift с уникальным именем (например 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

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

Описание типов

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

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

var welcomeMessage: String

Двоеточие в объявлении означает «…типа…», таким образом код выше можно прочитать так: “Объявить переменную с именем welcomeMessage и типом String”
Фраза «типа String» означает «может хранить любое значение String».
Переменной welcomeMessage любое строковое значение и это не вызовет ошибки:

welcomeMessage = "Hello"

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

var red, green, blue: Double

Примечание
На практике вам редко придется писать описание типа. Если вы присваиваете начальное значении константе или переменной в момент ее объявления, Swift почти всегда автоматически определит тип переменной. В примере выше переменная объявляется без присвоения значения, поэтому мы указали тип.

Именование Констант и Переменных

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

let π = 3.14159
let 你好 = «你好世界»
let cowdog variable = «dogcow»

В именах констант и переменных не могут использоваться математические символы, стрелки, private-use (or invalid) Unicode code points, or line- and box-drawing characters. Так же имя не может начинаться с цифры, но далее цифры могут быть использованы в любом месте имени.

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

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

Вы можете изменять значение переменной на любое другое значение соответсвующего типа. В этом примере значение переменной friendlyWelcome изменяется с «Hello!» на «Bonjour!»:

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

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

let languageName = "Swift"
languageName = "Swift++"
//вторая строка вызовет ошибку компиляции - константа  languageName не может быть изменена

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

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

println(friendlyWelcome)
// prints "Bonjour!"

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

Функция println выводит любое значение типа String, которое вы передали ей:

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

Функция println может выводить более сложные комплексные сообщения для записи в лог, аналогичным образом как функция Cocoa’s NSLog. Выводимые сообщения могут содержать текущие значения констант и переменных.

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

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

Примечание
Все возможности интерполяции строк описаны в главе «Интерполяция строк».

Комментарии

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

Комментарии в 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 = "big cat"; println(cat)
// prints "big cat"

Целые

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

В Swift можно использовать целые со знаком и без, длиной 8, 16, 32 и 64 бита. Обозначение типов целых совпадает с C, например беззнаковое 8 битное значение имеет тип UInt8 (unsigned integer 8 bit), а 32ух битное знаковое относится к типу Int32 (integer 32 bit). Имена типов целых, так же как и всех остальных типов в Swift, зарезервированные (системные) имена.

Границы целых
можно получить максимальное или минимальное значение любого типа целых (integer) используя специальные свойства:

let minValue = UInt8.min // minValue is equal to 0, and is of type UInt8 //minValue равняет 0 и это минимальное значение UInt8 
let maxValue = UInt8.max // maxValue is equal to 255, and is of type UInt8 //maxValue  = 255, максимальное значение UInt8 

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

Тип Int
В большинстве случаев нет необходимости устанавливать размер целых при объявлении. В Swift есть специальный тип Int, который установить макс значение соответствующее платформе:
На 32-битных платформах Int соответствует Int32
На 64-битных — Int64

Всегда используйте Int если точно не знаете, что значение должно быть определенного размера. This aids code consistency and interoperability. Даже на 32-битных платформах Int может хранить от -2,147,483,648 до 2,147,483,647 и этого достаточно для большинства операций с целыми.

Тип UInt (Unsignet Int/Беззнаковые целые)
В Swift также можно использовать тип UInt, размер которого устанавливается в зависимости от платформы:
На 32-битных платформах UInt соответствует UInt32
На 64-битных — UInt64.

Примечание
Используйте UInt только в том случае, если точно известно что значение должно быть беззнаковым. Если это не так используйте Int. Лучше использовать Int даже если предположительно значания будут >= 0. A consistent use of Int for integer values aids code interoperability, avoids the need to convert between different number types, and matches integer type inference, as described in Type Safety and Type Inference.


Числа с плавающей запятой (дробные)

Числа с плавающей запятой это числа с дробной частью, например 3.14159, 0.1, и -273.15.
Типы данных с плавающей запятой могут хранить более широкий диапазон значений чем типы целых. В Swift есть два типа дробных со знаком:
Double используется для хранения 64-битных значений с плавающей запятой. Используйте этот тип когда у вас действительно большие значения.
Float используется для хранения 32-битных значений с плавающей запятой. Используйте, если вам не требуются очень большие значения, как Double.

Примечание
Double может хранить до 15 чисел после запятой, Float — 6. Выбор необходимого типа зависит от значений с которыми предполагается работать в программе.

Постоянный тип значений. Автоматическое определение типа.

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

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

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

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

Практически определение типа используется когда вы объявляете переменную или константу со значением, т.е. сразу при объявлении присваиваете ей значение.
Например, если при объявлении константы вы присвоите ей значение 42, без явного указания типа, Swift автоматически присвоит ей тип Int, т.к. это значение больше всего подходит к типу Integer:

let meaningOfLife = 42
// meaningOfLife is inferred to be of type Int
// тип константы meaningOfLife - Int

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

let pi = 3.14159
// pi is inferred to be of type Double
// тип константы pi - Double

Значениям с плавающей запятой всегда присваивается тип Double (не Float) если не указано явно.
Если вы присвоите значение вычисления Int и Double, результату будет присвоен тип Double:

let anotherPi = 3 + 0.14159
// anotherPi is also inferred to be of type Double
// константе anotherPi присвоен тип Double

В данном случае значение 3 может быть отнесено к нескольким типам (Int, Uint, Double, Float), но значение 0.14159 может быть только Double, поэтому результат этого сложения тоже Double.

Числовые значения

Целочисленные значения могут записываться в нескольких системах счислений:
Число в десятеричной системе записывается без префикса.
В двоичной системе с префиксом 0b.
В восьмеричной системе с префиксом 0o.
В шестнадцатеричной системе с префиксом 0x.
Все нижеприведенные примеры имеют десятеричное значение 17:

let decimalInteger = 17
let binaryInteger = 0b10001 // 17 в двоичной системе
let octalInteger = 0o21 // 17 в восьмеричной системе
let hexadecimalInteger = 0x11 // 17 в шестнадцатеричной системе

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

1.25e2 означает 1.25 × 102, или 125.0. (в ст. 2)
1.25e-2 означает 1.25 × 10-2, или 0.0125. (в ст. -2)

0xFp2 означает 15 × 22, или 60.0. (ст.2)
0xFp-2 означает 15 × 2-2, или 3.75.(ст.-2)

Все нижеприведенные примеры имеют десятеричное значение 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, если вы знаете что значения не будут отрицательными. При использовании типа Int во сех стандартных ситуациях вы можете быть уверены что константы и переменные этого типа будут корректно взаимодействовать с друг другом и вам не потребуются дополнительные преобразования.

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

Преобразования целочисленных типов

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

let cannotBeNegative: UInt8 = -1
// UInt8 не может хранить отрицательные значение, это действие вызовет ошибку
let tooBig: Int8 = Int8.max + 1
// Int8 не может хранить значение больше чем его определенный максимум, это действие вызовет ошибку

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

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

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

Тип обоих слагаемых UInt16, поэтому сложение не вызовет ошибок. Результирующей константе (twoThousandAndOne) будет присвоен тип UInt16, т.к. значение присваиваемое ей это сложение двух значений 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
//pi равно  3.14159, и ему присвоен тиg Double

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

Значения с плавающей запятой так же можно преобразовать в целые.В примере ниже Double преобразовывается в Int:

let integerPi = Int(pi)
// integerPi equals 3, and is inferred to be of type Int
// integerPi равно 3, тип Int

При преобразовании дробных к целым, дробная часть всегда отсекается. Например 4.75 станет 4, -3.9 станет 3

Примечание
The rules for combining numeric constants and variables are different from the rules for numeric literals. The literal value 3 can be added directly to the literal value 0.14159, because number literals do not have an explicit type in and of themselves. Their type is inferred only at the point that they are evaluated by the compiler.

Алиасы для типов

Алиасы (aliases) позволяют задать еще одно имя для уже существующего типа. Для создания нового имени используется ключевое слово typealias.
Алиасы удобно использовать для большей читабельности, когда вы работаете с данными определенного размера. Например:

typealias AudioSample = UInt16

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

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

В примере выше AudioSample алиас UInt16, поэтому мы можем использовать AudioSample.min и получим значение как UInt16.min.

Булев тип
В свифт есть обычный булев тип, Bool. Булевы значения -логические, они могу содержать только «истина» или «ложь».

let orangesAreOrange = true
let turnipsAreDelicious = false

Тип orangesAreOrange и turnipsAreDelicious определен как Bool потому, что они инициализированы булеановыми значениями. Так же как с Int и Double, вам не обязательно указывать тип Bool при создании константы или переменной, если вы присваиваете им сразу true или false.

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

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

Проверка типов в 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, соответственно ошибки не будет.

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

В примере ниже мы создаем константу типа tuple которая описывает HTTP status code. HTTP status code это специальное значение возвращаемое вебсервером при запросе страницы. Код 404 возвращается сервером, в случае если страница не найдена.

let http404Error = (404, "Not Found")
// http404Error is of type (Int, String), and equals (404, "Not Found")
// http404Error соджержит значения типа Int и String

(404, «Not Found») группирует Int и String для хранения двух значений HTTP status code: числовой номер возвращаемый серверов и понятный для пользователя — текстовый. Константа в примере выше может быть описана так: tuple типа (Int, String) .

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

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

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"

Значения хранящиеся в tuples можно именовать при объявлении:

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

Если значения в tuples поименованы, можно использовать именование для доступа к значениям:

 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"

На практике Tuples удобно использовать как возвращаемое значение функции. Например, функция которая получает содержимое вебстраницы может сразу вернуть статус в типа Int и String в tuples. При возвращении tuples с несколькими типами вы получите сразу больше полезной информации, в отличии от того если бы она возвращала только строку или целое и т.п.

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

Optionals
Optionals используются в ситуациях, когда значение может отсутствовать. Прочитать можно так:
Есть значение и оно равно X, либо нет никакого значения.

Примечание
Концепции optional нет в C or Objective-C. Ближайшее, что есть в Objective-C это возможность вернуть nil из метода или объект, где nil будет означать «отсутствие корректного объекта». Однако, это работает только для объектов и не работает для structs, basic C types, or enumeration values. Для этих типов в Objective-C обычно возвращается специальное значение (например NSNotFound) для обозначения отсутствия значения.

У типа String есть метод toInt, который пытается преобразовать строку в целое. Однако, не любая строка может быть конвертирована в целое. Строка «123» может быть преобразована в 123, но строка «hello, world» не имеет никакого соответствующего числового значения в которое может быть конвертирована.
Пример ниже показывает как это работает:

let possibleNumber = "123"
let convertedNumber = possibleNumber.toInt()
// convertedNumber is inferred to be of type "Int?", or "optional Int"
// convertedNumber  присвоен тип "Int?", или "optional Int"

Т.к. метод toInt не всегда может вернуть значение, он возвращает optional Int, а не Int. Optional Int записывается как Int?, а не Int. Знак вопроса в записи означает, что это optional, т.е. может содержать какое-либо значение или не содержать его вовсе.

Выражение If и Forced Unwrapping
Вы можете использовать выражение if для проверки, содержит ли optional какое-то значение. Если значение есть, то if попадает в блок true, если нет, то в false.

Если вы точно знаете, что ваш optional имеет какое-то значение, то получить доступ к нему можно, поставив в конце восклицательный знак (!). Прочитать такое выражение можно так: «Я знаю что optional содержит значение. Пожалуйста, используй его.» Так же это называется forced unwrapping значения optional:

if convertedNumber {
println("\(possibleNumber) has an integer value of \(convertedNumber!)")
} else {
println("\(possibleNumber) could not be converted to an integer")
}
// prints "123 has an integer value of 123"

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

Optional Binding
Optional binding используется для проверки содержит ли optional значение, и если да, то присваивания значения временной переменной или константе. Optional binding можно использовать с оператором if и while для проверки значения содержащегося в optional и присвоения значения константе или переменной.

Пример ниже:

if let constantName = someOptional {
statements
}
You can rewrite the possibleNumber example from above to use optional binding rather than forced unwrapping:
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"

Это можно прочесть так:
“Если optional Int вернет функцией possibleNumber.toInt значение, присвоить это значение новой константе actualNumber.”

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

Можно использовать как константы, так и переменные с optional binding. Если вам нужно использовать переменную, вместо константы, то следует написать if vat … вместо if let …

Отрывок из книги: Inc, Apple. «The Swift Programming Language.» Apple Inc., 2014-07-16T07:00:00Z. iBooks.
Посмотрите эту книгу в iBooks Store: https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329
По мере перевода статья будет обновляться.