Числовые данные представлены следующими типами:
Int8: целое число со знаком размером не более 8 бит (от -128 до 127)
UInt8: целое положительное число размером не более 8 бит (от 0 до 255)
Int16: целое число со знаком размером не более 16 бит (от -32768 до 32767)
UInt16: целое положительное число размером не более 16 бит (от 0 до 65535)
Int32: целое число со знаком размером не более 32 бита (от -2147483648 до 2147483647)
UInt32: целое положительное число размером не более 32 бита (от 0 до 4294967295)
Int64: целое число со знаком размером не более 64 бита (от -9223372036854775808 до 9223372036854775807)
UInt64: целое положительное число размером не более 64 бита (от 0 до 18446744073709551615)
Int: целое число со знаком, например, 1, -30, 458. На 32-разрядных платформах эквивалентен Int32, а на 64-разрядных - Int64
UInt: целое положительное число, например, 1, 30, 458. На 32-разрядных платформах эквивалентен UInt32, а на 64-разрядных - UInt64
Float: 32-битное число с плавающей точкой, содержит до 6 чисел в дробной части
Double: 64-битное число с плавающей точкой, содержит до 15 чисел в дробной части
Float80: 80-битное число с плавающей точкой
В дополнение фреймворк Core Graphics поддерживает тип CGFloat, чей размер зависит от архитектуры и может быть аналогичен либо типу Float, либо типу Double.
Для работы с числами в Swift можно использовать целочисленные литералы (типа 2, 3, 78) и литералы чисел с плавающей точкой, в которых разделителем между целой и дробной частью является точка, например, 1.2, 3.14, 0.025. При этом все целочисленные литералы рассматриваются как значения типа Int, а все дробные литералы - как значения типа Double.
let a = 2 // Int let b = 2.0 // Double
Если мы хотим присвоить числовой литерал переменным или константам типов, отличных от Int и Double, то компилятор может автоматически выполнять преобразование:
let n : Int16 = 10 // неявное преобразование от Int к Int16 let x : Float = 3.14 // неявное преобразование от Double к Float
Для числовых типов большое значение имеет размерность, то есть количество бит, которое данный тип содержит. Например, тип UInt8 не может
хранить число больше чем 255. Поэтому у нас не получится присвоить переменной этого типа, например, число 1000:
var age: UInt8 = 1000 //здесь ошибка
Минимальное и максимальное значение для определенного числового типа можно получить с помощью констант min и max:
var minInt16 = Int16.min // -32768 var maxInt16 = Int16.max // 32767 var minUInt16 = UInt16.min // 0 var maxUInt16 = UInt16.max // 65535
По умолчанию Swift работает с десятичной системой исчисления. Однако, как и многие другие языки программирования, он может работать и с другими системами:
десятичная: числа используются так, как они есть, без каких-либо префиксов
двоичная: перед числом используется префикс 0b
восьмеричная: перед числом используется префикс 0o
шестнадцатеричная: перед числом используется префикс 0x
Например, запишем число 10 во всех системах исчисления:
let decimalInt = 10 let binaryInt = 0b1010 // 10 в двоичной системе let octalInt = 0o12 // 10 в восьмеричной системе let hexInt = 0xA // 10 в шестнадцатеричной системе
Для чисел с плавающей точкой возможна запись в двух системах: десятичной и шестнадцатеричной. Для упрощении записи длинных чисел в десятичной системе мы можем
использовать символ e (экспонента). Например:
var a = 1.25e2 // 125 var b = 1.25e-2 // 0.0125
Для записи чисел с плавающей точкой в шестнадцатеричной системе используется префикс p:
var a = 0xFp2 //15 * 2 в степени 2 или 60.0 var b = 0xFp-2 //15 * 2 в степени -2 или 3.75
Swift обладает полноценным набором арифметических операций. Арифметические операции производятся над числами:
+
Сложение двух чисел:
var a = 6 var b = 4 var c = a + b // 10
-
Вычитание двух чисел:
var a = 6 var b = 4 var c = a - b // 2
-
Унарный минус. Возвращает число, умноженное на -1:
var a = -6 var b = -a // 6 var c = -b // -6
*
Умножение:
var a = 6 var b = 4 var c = a * b // 24
/
Деление:
var a = 8 var b = 4 var c = a / b // 2
При делении стоит учитывать, какие данные участвуют в делении и какой результат мы хотим получить. Например, в следующем случае выполняется деление дробных чисел:
let n : Double = 10 let d : Double = 4 let x : Double = n / d // 2.5
Результатом операции чисел Double является значение типа Double, которое равно 2.5. Но если мы возьмем значения типа Int, то результат будет иным:
let n : Int = 10 let d : Int = 4 let x : Int = n / d // 2
Оба операнда операции представляют тип Int, поэтому результатом операции является значение типа Int. Оно не может быть дробным, поэтому дробная часть отбрасывается, и мы получаем не 2.5, а число 2.
%
Возвращает остаток от деления:
var a = 10 var b = 4 var c = a % b // 2
При арифметических операциях надо учитывать, что они производятся только между переменными одного типа. Например, в следующем примере мы получим ошибку:
var a: Int8 = 10 var b: Int32 = 10 var c = a + b
a и b должны в данном случае представлять один и тот же тип.
И также арифметические операции возвращают объект того же типа, к которому принадлежат операнды операции. Например, в следующем примере мы получим ошибку:
var a: Int8 = 10 var b: Int8 = 10 var c: Int32 = a + b
В данном случае переменная c, как и a и b, также должна представлять тип Int8.
Ряд операций сочетают арифметические операции с присваиванием
+=
Присвоение со сложением, прибавляет к текущей переменной некоторое значение:
var a = 6 a += 10 print(a) // 16 // эквивалентен // a = a + 10
-=
Присвоение с вычитанием, вычитает из текущей переменной некоторое значение:
var a = 10 a -= 6 print(a) // 4 // эквивалентно // a = a - 6
*=
Присвоение с умножением, умножает текущую переменную на некоторое значение, присваивая ей результат умножения:
var a = 10 a *= 6 print(a) // 60 // эквивалентно // a = a * 6
/=
Присвоение с делением, делит значение текущей переменной на другое значение, присваивая результат деления:
var a = 10 a /= 2 print(a) // 5 // эквивалентно // a = a / 2
%=
Присвоение с остатком от делением, делит значение текущей переменной на другое значение, присваивая переменной остаток от деления:
var a = 10 a %= 4 print(a) // 2 // эквивалентно // a = a % 4