Существует 4 основных типа данных, которые Swift рекомендует использовать программистам. Это String, Int, Double и Bool.
String для текста, Int для целого числа, Double для числа с плавающей запятой и Bool для хранения логического значения (истинные или ложные) значения.
В дополнение к базовому типу данных 4 мы также можем использовать целое число без знака, представленное UInt, и меньшее число с плавающей запятой, представленное Float.
Как для целых чисел со знаком, так и для целых чисел без знака их можно разбить на целые числа битового размера. Восьмибитное целое число со знаком представлено Int8. Для целого числа со знаком у нас есть Int8, Int16, Int32 и Int64. Точно так же для целого числа без знака у нас также есть UInt8, UInt16, UInt32 и UInt64.
Реализации целых чисел, чисел с плавающей запятой и логических значений очень похожи на многие другие языки программирования типа C, такие как C, C# или Objective-C. Реализация String будет отличаться для разных языков программирования. В этой статье мы рассмотрим основы String.
В этой статье мы также представим новый тип данных, который отличается от других языков программирования. Кортежи — это тип данных, который содержит группу значений. Эти значения могут быть созданы с использованием комбинации другого базового типа данных. Мы можем сгруппировать несколько значений в кортеж и передать несколько значений, как если бы мы работали с одной переменной. (Подсказка: для программирования C Tuples аналогичны struct).
Swift также представляет тип данных, называемый типом данных Optionals. Необязательные параметры обрабатывают ситуацию, когда в переменной нет значения. Это похоже на нулевые указатели в Objective-C, но необязательные параметры применяются ко всем типам данных Swift. Факультативы безопаснее нулевых указателей в Objective-C. Используя оператор if и необязательные параметры, Swift представляет метод программирования, называемый необязательным связыванием, который обеспечивает безопасную проверку всех переменных. Необязательная привязка — одна из ключевых функций программирования на Swift.
Целые числа
В Swift целые числа — это целые числа. Целочисленный тип данных принимает только целое число. Например, целые числа принимают такие числа, как 54 или 57791.
Целые числа можно дополнительно разделить на целые числа со знаком и целые числа без знака. Целые числа со знаком принимают отрицательные целые числа и положительные целые числа. Примеры целых чисел со знаком: 57, -325 и -54623. Целые числа без знака принимают только положительные целые числа, такие как 723 и 9394.
Целые числа со знаком обозначаются Int, а целые числа без знака обозначаются UInt.
Кроме того, Swift также предоставляет целое число в битах. Беззнаковое целое размером 8 бит обозначается UInt8. Swift предоставляет 4 целых числа без знака, это UInt8, UInt16, UInt32 и UInt64. Чем больше размер бита, тем большее число может содержаться. Например, UInt8 принимает только числа от 0 до 255, тогда как UInt64 может принимать числа от 0 до 18446744073709551615.
Точно так же Swift также предоставляет целое число с 4 битами со знаком, это Int8, Int16, Int32 и Int64. Для целого числа со знаком он может содержать примерно половину размера целого числа без знака. Это связано с тем, что целое число со знаком также принимает отрицательное число. Целое число со знаком принимает 1 и -1. Поэтому Int8 может принимать только числа от -128 до 127.
Таким образом, у нас есть следующие типы целых чисел. Int, UInt, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32 и UInt64.
Прежде чем мы поговорим об этих целых числах, нам нужно обсудить числовые литералы, которые формируют необработанные данные для целых чисел.
Числовые литералы
Прежде чем мы начнем обсуждать целые числа и числа с плавающей запятой, мы должны изучить числовые литералы. В программировании числовые литералы — это буквально числа в необработанном виде, такие как 254, -58, 2,655.
В Swift мы принимаем числовые литералы в другой форме. Помимо десятичного числа, Swift также принимает числовое число в двоичной, шестнадцатеричной и восьмеричной форме. Чтобы различать десятичную и другую форму числа, мы должны включить префикс для следующего типа числа:
Binary: 0b Hexadecimal: 0x Octal: 0o
Например, число 255 можно записать в следующем виде, и это допустимо в Swift:
Decimal 255 Binary 0b1111 1111 Hexadecimal 0xFF Octal 0o377
Мы можем объявить константу или переменную, используя эту форму числа.
let constantAA = 255 var variableBB = 0b11111111 let constantCC = 0xFF var variableDD = 0o377
Мы также можем смешивать различные числовые формы во время вычислений.
let constantEE = 255 + 0b11111111 + 0xFF + 0o377 let constantFF = 255 + 255 + 255 + 255
Мы также можем включить другую числовую форму в оператор печати, используя интерполяцию строк:
print("The number of 0xFFFF is \(0xFFFF).")
Мы обычно не используем другую числовую форму для ввода данных. Мы можем использовать их, если нам нужно запрограммировать определенные функции, требующие другой числовой формы.
Для большей части наших функций программирования мы придерживаемся десятичной формы.
Кроме того, мы также можем использовать подчеркивание (_), чтобы разделить большое число, чтобы улучшить читаемость. Например, 10 миллиардов — это 10 000 000 000. Мы можем представить число как 10_000_000_000.
Далее мы изучим целое число в битах, прежде чем узнаем об UInt и Int.
Битовое целое
В основном у нас есть 8 типов целых чисел, 4 целых числа со знаком и 4 целых числа без знака. Это Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32 и UInt64.
Каковы различия? Основные отличия заключаются в их разрядности. UInt8 имеет длину всего 8 бит, тогда как UInt64 имеет длину 64 бита. Чем больше размер бита, тем большее число может быть сохранено. Например, UInt8 может хранить числа от 0 до 255, тогда как UInt32 может хранить числа от 0 до 4294967295.
Для целого числа со знаком мы можем хранить даже меньшее число, потому что нам нужно учитывать отрицательное число. Int8 нужно принимать 1 и -1. Таким образом, Int8 может принимать числа от -128 до 127. Таким образом, возможности хранения уменьшаются почти вдвое для целых чисел со знаком.
Ниже приведена таблица, в которой перечислены допустимые числа для каждого целого числа:
Как видно из таблицы, чем больше разрядность, тем большее число можно поместить в переменную.
Объявленное целое число на основе битов
Чтобы объявить целое число в битах, мы должны включить аннотацию типа данных, потому что без аннотации типа данных система будет выводить любое целое число как Int вместо Int16.
Вывод данных не работает с целым числом в битах.
Синтаксис следующий:
let ‹constant_name›:‹bit_sized_integer_type› = ‹numeric_literals/выражение, полученное из числа›
Or
var ‹variable_name›:‹bit_sized_integer_type› = ‹numeric_literals/выражение, полученное из числа›
См. приведенный ниже пример.
Пример:
let smallestNumber:Int8 = 127 var smallNumber:Int16 = 32767 let bigNumber:UInt32 = 4294967295 var biggerNumber:UInt64 = 18446744073709551615
Работа с битовым целым числом
Мы редко объявляем целое число битов, если только нам не нужна константа или переменная, фиксированная с определенным размером на всех разных платформах (32-битная система и 64-битная система).
Чтобы узнать, какое максимальное или минимальное число может принять целочисленный тип, мы добавляем к типу данных .min для минимального числа и .max для максимального числа.
См. пример ниже:
let minOfInt8 = Int8.min let maxOfInt8 = Int8.max let minOfUInt64 = UInt64.min // For unsigned integer the min is always 0 let maxOfUInt64 = UInt64.max
Мы не должны использовать целое число в битах, кроме как в исключительных случаях. Вместо этого мы должны использовать целое число со знаком по умолчанию (Int). Даже если мы работаем с очень небольшим числом, не превышающим 100, нам не следует использовать Int8 или UInt8. Использование Int8 не дает никаких преимуществ по сравнению с использованием Int.
В прежние времена, когда памяти боялись, использование Int8 имело смысл, чтобы мы могли экономить память. Использование Int8 также не улучшит скорость обработки и даже может замедлить скорость обработки, поскольку большинство операционных систем оптимизированы для операций 64-разрядного процессора.
Беззнаковое целое
Как упоминалось ранее, целое число без знака принимает только положительное число. Целое число без знака представлено UInt. Но насколько велик UInt? Что ж, UInt меняется в зависимости от операционной среды, особенно от размера процессора.
- Если компьютер работает на 32-разрядном процессоре, то UInt эквивалентен UInt32.
- Если компьютер работает на 64-разрядном процессоре, то UInt эквивалентен UInt64.
Все устройства Apple, от MacBook до iPad, работают на разных процессорах. Все современные продукты Apple (кроме Apple Watch) теперь работают на 64-битном процессоре. Однако более старые устройства Apple могут работать на 32-разрядном процессоре.
Если наши приложения будут работать как на 32-битной, так и на 64-битной платформе, нам нужно выяснить, какое ограничение UInt для конкретной платформы. Точно так же мы можем узнать максимальное значение, добавив .max к UInt.
Из результата мы сделали вывод, что UInt эквивалентен UInt64.
Обратите внимание на это, когда мы разрабатываем приложения для iPad или часов Apple старшего поколения.
Чтобы использовать целое число без знака, мы должны объявить его с аннотацией типа данных. Вывод типа данных не работает с целыми числами без знака.
Синтаксис следующий:
let ‹имя_константы›:UInt = ‹числовые_литералы/выражение, полученное из числа›
Or
var ‹имя_переменной›:UInt = ‹числовые_литералы/выражение, преобразованное в число›
Пример 1:
let someUnsignedNumber:UInt = 787
Пример 2:
var someUnsignedVariable:UInt = 54
someUnsignedVariable = 768
print("The unsigned number is \(someUnsignedVariable).")
Целое число без знака можно распечатать с помощью функции печати, вставив константу или переменную в круглые скобки.
Мы также можем напечатать целое число без знака с помощью интерполяции строк.
Swift рекомендует нам использовать целое число со знаком по умолчанию, чтобы обеспечить лучшую совместимость кода. Мы не должны использовать целое число без знака, если только нам не нужно запускать большое число, и число превышает максимальный предел целого числа со знаком.
Даже если мы используем только положительное число, рекомендуется использовать значение Int по умолчанию. Использование Int улучшает совместимость нашего кода и предотвращает преобразование между различными целыми числами.
Как упоминалось в предыдущем разделе, использование UInt не увеличивает скорость обработки для повышения эффективности. Используйте UInt только тогда, когда нам нужны числа больше, чем может принять целое число со знаком.
Целое число со знаком
Точно так же целое число со знаком также получено из размера нашего процессора.
- Если компьютер работает на 32-разрядном процессоре, то Int эквивалентен Int32.
- Если компьютер работает на 64-разрядном процессоре, то Int эквивалентен Int64.
Чтобы узнать максимальный и минимальный предел, мы можем сделать это, добавив .max и .min.
let minLimitInt = Int.min let maxLimitInt = Int.max
Целое число со знаком (Int) используется по умолчанию для вывода типа данных. Любое целое число будет автоматически выведено и присвоено типу данных Int. Поэтому нам не нужно включать аннотацию типа данных при объявлении константы или переменной.
Для лучшей совместимости кода мы должны использовать Int, когда это возможно, даже если мы используем только положительное число.
Целочисленное переполнение
Читатели, знакомые с программированием на Objective-C или C, должны знать, что если мы добавим 1 к максимальному пределу, целочисленная переменная переполнится. В Swift нет целочисленного переполнения. Если мы добавим 1 к максимальному значению, это просто вызовет ошибку.
Число с плавающей запятой
Числа с плавающей запятой - это дробные десятичные числа. Например, 3,1415, 0,22 и -5,23 — это числа с плавающей запятой. Также рекомендуется использовать число с плавающей запятой для деления, если мы не хотим отбросить остаток.
В программировании Swift числа с плавающей запятой представлены двумя типами данных. Они бывают двойными и плавающими. Double — это 64-разрядное число с плавающей запятой с точностью не менее 15 знаков после запятой, тогда как Float — это 32-разрядное число с плавающей запятой с точностью до 6 знаков после запятой.
Также обратите внимание, что число с плавающей запятой не ограничено разрядностью процессора. Обычно он вычисляется устройством с плавающей запятой (также известным как сопроцессор или математический процессор).
Литералы с плавающей запятой
Для числа с плавающей запятой оно может быть представлено десятичными литералами и шестнадцатеричными литералами с префиксом 0x.
Литералы с плавающей запятой для десятичного числа должны иметь десятичную точку с числом по обе стороны от десятичной точки.
Например, число 132 будет восприниматься как Int. Чтобы система могла вывести число в число с плавающей запятой, мы должны записать 132 как 132.0.
Кроме того, мы также можем включить показатель степени с буквой E или e. Чтобы записать число с показателем степени, число 255 можно записать как 2,55 x 10². В программировании на Swift мы можем записать число в экспоненте, используя E или e для представления x10. Число после E или e является показателем степени. Мы можем использовать E или e, поскольку они обозначают одно и то же.
Например, 2,55 х 10² можно записать как 2,55e2.
Примеры:
let fpLiteral2 = 3.1415 let fpLiteral3 = 2.55e2 let fpLiteral4 = 2.55E2 let fpLiteral5 = 25.64E4
Еще пример:
// Decimal: use e for exponential let val22 = 2.1718 let val23 = 0.021718e2 let val24 = 217.18e-2
Плавающая точка также может быть записана в шестнадцатеричной форме. Чтобы записать число с плавающей запятой в шестнадцатеричном формате, мы должны добавить префикс 0x. Кроме того, нам нужно записать в форме экспоненты, используя p в качестве экспоненты вместо e. P представлен 2exp. В этом случае exp можно представить в десятичном виде. Следовательно, число после p должно быть десятичным.
Например, для 255 можно записать как 0xFFp0. Число 0xFFp3 эквивалентно 255 x 23 = 2040.
Дополнительный пример:
// Hex: use p for exponential let val25 = 0xFFp2 let val26 = 0xFFp1 let val27 = 0xFFp0 let val28 = 0xFFp-1 let val29 = 0xFFp-2
Еще пример:
// More example: All the following numeric literals refer to the same number. let val30 = 12.1875 let val31 = 1.21875e1 let val32 = 0xC.3p0
Мы также можем использовать подчеркивание, чтобы разделить десятичные разряды на более удобочитаемый раздел.
Пример:
// We can use _ and padded 0 for readability let val34 = 000223.000655 let val35 = 000_223.000_655
Плавать
Float — это 32-битное число с плавающей запятой, точность которого ограничена 6 знаками после запятой. Поскольку Float имеет ограниченную точность, не рекомендуется использовать его без крайней необходимости.
Чтобы объявить константу или переменную Float, нам нужно включить аннотацию типа данных. Вывод типа данных не работает с Float.
Синтаксис следующий:
let ‹имя_константы›:Float = ‹число_с_плавающей_точкой/выражение_что_производное_в_плавающей_точке›
Or
var ‹имя_переменной›:Float = ‹число_с_плавающей_точкой/выражение_которое_производно_в_с_плавающей_точкой›
Пример:
let shortPi:Float = 3.14159265359 let longPi = 3.14159265359
Как упоминалось ранее, Float имеет ограниченную точность. Если мы введем десятичное число с длинными десятичными цифрами, оно будет округлено до ближайших 6 знаков после запятой.
Если число, которое мы вычисляем, не превышает двух знаков после запятой, более эффективно использовать Float? Ответ не нужен, в настоящее время память очень доступна, поэтому мы не сэкономим много места в памяти, если будем придерживаться Float. Выполнение CPU — сложный процесс, поэтому использование Float может не помочь ускорить выполнение. Это может даже замедлить выполнение из-за дополнительного цикла ожидания.
Двойной
Double — это 64-битное число с плавающей запятой с точностью не менее 15 знаков после запятой. Это рекомендуемый тип данных для десятичного числа.
Чтобы объявить константу или переменную с назначением данных, нам не нужно включать аннотацию типа данных, поскольку система будет выводить любое десятичное число как Double.
Синтаксис следующий:
пусть ‹имя_константы› = ‹число_с_плавающей_точкой/выражение_которое_производное_в_плавающей_точке›
Or
var ‹имя_переменной› = ‹число_с_плавающей_точкой/выражение_которое_производное_в_с_плавающей_точкой›
Пример:
let someFPNumber = 2.1718 let pi = 3.1415 let radius = 1.2
Нить
В Swift String — это тип данных, который обрабатывает текст. Это наиболее часто используемый тип данных. Swift также включает тип данных, известный как Character, который содержит один символ. В этом разделе мы кратко обсудим основные функции. Для более полного изучения обратитесь к главе «Работа со строками».
Строковые литералы — это в основном необработанный текст, который может принять Swift. Swift может принимать все виды текста в Юникоде, кроме обратной косой черты (\), двойных кавычек («) и тройных двойных кавычек («»»).
Двойная кавычка используется для заключения текста и является маркером, который отмечает начало и конец текста. Тройные двойные кавычки используются для заключения многострочного текста.
Пример:
"This is a text"
"!@#$%^&*()_+=-:’;><?,./|{}[]"
В Swift 4 String поддерживает многострочные литералы. Чтобы создать многострочные литералы, мы заключаем весь текст в тройные двойные кавычки. Начало многострочной строки должно начинаться с новой строки после открывающей тройной двойной кавычки.
Пример:
let story = """ Title We can include multi line text here. Next paragraph End """ print(story)
Swift может принимать любые символы Юникода.
Пример:
Если мы знаем номер юникода, мы можем использовать номер юникода, используя следующий синтаксис:
«\u{‹unicode_number›}»
Пример:
"\u{2EE5}"
"\u{2F25}\u{2F26}"
Расширенный кластер графем — это последовательность юникода для формирования символа. Во многих иностранных языках слова образуются комбинацией символов или штрихов.
Пример:
"\u{110B}"
"\u{1175}"
"\u{110B}\u{1175}"
"\u{C774}"
Поскольку нам нужно заключить строку в двойные или тройные двойные кавычки, мы не можем использовать двойные или тройные двойные кавычки в строке. Чтобы смягчить эту проблему, мы создаем escape-последовательность, представленную обратной косой чертой (\). Поэтому мы не можем использовать в строке двойные кавычки ("), тройные двойные кавычки (""") и обратную косую черту (\).
Чтобы использовать эти 3 символа, нам нужно использовать обратную косую черту в качестве управляющей последовательности. Чтобы использовать двойные кавычки в строке, нам нужно ввести \" вместо ", аналогично, чтобы использовать обратную косую черту в строке, нам нужно ввести \\ вместо \. Чтобы включить тройную двойную кавычку, мы можем использовать \""" или \"\"\". Нам не нужна управляющая последовательность для двойной кавычки в многострочном тексте.
Создать строку
Если мы хотим, чтобы строковое значение оставалось неизменным и неизменным, мы должны создать строковую константу.
Мы можем создать строковую константу, используя следующий синтаксис:
let ‹constant_name› = ‹строковые литералы/строковые выражения›
Пример:
let stringConstant = "This is a string constant"
Если нам нужно строковое значение, и мы хотим, чтобы оно изменялось по мере необходимости, нам следует создать строковую переменную.
Строковая переменная может быть создана с использованием следующего синтаксиса:
var ‹имя_переменной› = ‹строковые литералы/строковое выражение›
Пример:
var stringVariable1 = "Default string value" stringVariable1 stringVariable1 = "New string value" stringVariable1
Мы можем создать пустую строку, просто указав двойную кавычку:
var ‹имя_переменной› = «»
В качестве альтернативы мы также можем использовать приведенный ниже синтаксис. Оба метода производят одинаковые эффекты.
var ‹имя_переменной› = String()
Пример:
var stringVariable3 = "" var stringVariable4 = String()
Чтобы проверить, пуста ли строковая константа/переменная, мы используем свойство isEmpty
Пример:
stringVariable3.isEmpty stringVariable4.isEmpty
- Мы можем соединять строки с помощью оператора плюс (+).
- Мы можем соединять строковые литералы и/или строковые переменные.
Пример:
let stringSample1 = "This is a test." + " And this is the second part of a jointed string" print(stringSample1)
- Мы также можем соединить строку с помощью оператора (+=). Используя этот оператор, мы можем добавить новую строку в исходную строку.
Пример 4:
var stringSample7 = "Hello, " stringSample7 += "Welcome to the Star Fleet." print(stringSample7)
логический
Swift также поддерживает логический тип. Этот тип данных аннотируется как Bool. В отличие от некоторых других языков, таких как C, где false представлено 0, а true представлено числом, отличным от 0; в Swift true и false должны быть явно выражены. Истина должна быть выражена как истина, а ложь должна быть выражена как ложь.
Пример:
let myFact = true let myNonFact = false
Хотя логический тип данных явно определяется и выражается как истина или ложь. Внутри истинное значение имеет хеш-значение 1, а ложное значение имеет хэш-значение 0.
Мы можем прочитать хеш-значение, но не можем его изменить. Кроме того, использование функции печати будет печатать только истинное или ложное значение утверждения. Хэш-значение не может быть напечатано.
Пример:
let myTruth = true let myNonTruth = false myTruth.hashValue myNonTruth.hashValue print(myTruth) print(myNonTruth)
Способ логической работы в Swift отличается от программирования на C. В программировании на C мы можем использовать 0 и ненулевое значение для обозначения истинности и ложности. В Swift мы не можем оценивать и интерпретировать целое число как логическое значение. Следующий оператор не будет работать в Swift, но будет работать в C:
переменная х = 1
if x {…}
Нам нужно явно использовать if x == 1 для вычисления логического значения.
let boolTest = false
// The following is the preferred method to test boolean variable
if boolTest == true
{
print("boolTest is True")
}
else
{
print("boolTest is False")
}
Мы также можем использовать следующий формат без компаратора, поскольку логическое значение равно True или False.
if boolTest
{
print("boolTest is True")
}
else
{
print("boolTest is False")
}
Приведенный выше пример работал, потому что boolTest — логическая переменная.
Мы не можем использовать следующее, удалите комментарий, чтобы проверить
/*
let wrongWay1 = 1
if wrongWay1
{
print("wrongWay1 is True")
}
else
{
print("wrongWay1 is False")
}
*/
Приведенный выше пример приведет к ошибке, однако мы можем проверить целое число с помощью компаратора следующим образом.
let rightWay1 = 1
if rightWay1 == 1
{
print("rightWay1 is True")
}
else
{
print("rightWay1 is False")
}
Первоначально опубликовано на сайте blog.swifticode.com 3 апреля 2018 г.
