Swift (язык программирования)

Эта статья о языке программирования Apple. Информацию о языке сценариев см. в разделе Swift (язык параллельных сценариев) . Информацию о ядре ЦП см. в Apple A6 .

Быстрый

Логотип
Парадигма	Мультипарадигмальность : протокольно-ориентированная , объектно-ориентированная , функциональная , императивная , блочно-структурированная , декларативная , параллельная.
Разработано	Крис Лэттнер , Дуг Грегор, Джон МакКолл, Тед Кременек, Джо Грофф и Apple Inc.
Разработчик	Apple Inc. и участники открытого исходного кода
Впервые появился	2 июня 2014 г ( 2014-06-02 )
Стабильная версия	5.10  / 5 марта 2024 г ( 5 марта 2024 г. )
Предварительный выпуск	5.9
Дисциплина набора текста	Статический , сильный , предполагаемый
Управление памятью	Автоматический подсчет ссылок
ТЫ	Операционные системы Apple ( Darwin , iOS , iPadOS , macOS , tvOS , VisionOS , watchOS ), Linux , Windows , Android , z/OS
Лицензия	Лицензия Apache 2.0 (Swift 2.2 и новее) Собственный (до Swift 2.2)
Расширения имен файлов	.Свифт, .СВИФТ
Веб-сайт	www .быстрый .org разработчик .яблоко .с /быстрый /
Под влиянием
Цель-С , Rust , Haskell , Ruby , Python , C# , CLU , Д
Под влиянием
Ржавчина , V (Vlang)

Swift — это уровня общего назначения , многопарадигмальный компилируемый высокого язык программирования созданный Крисом Латтнером в 2010 году для Apple Inc. и поддерживаемый сообществом открытого исходного кода . Swift компилируется в машинный код, поскольку это компилятор на основе LLVM . Swift был впервые выпущен в июне 2014 года. а набор инструментов Swift поставляется в Xcode начиная с версии 6, выпущенной в 2014 году.

Apple предполагала, что Swift будет поддерживать многие основные концепции, связанные с Objective-C , в частности динамическую диспетчеризацию , широкое распространение позднего связывания , расширяемое программирование и подобные функции, но «более безопасным» способом, что упрощает обнаружение ошибок в программном обеспечении ; Swift имеет функции, устраняющие некоторые распространенные ошибки программирования, такие как нулевого указателя разыменование , и предоставляет синтаксический сахар , помогающий избежать пирамиды гибели . Swift поддерживает концепцию расширяемости протокола , систему расширяемости, которую можно применять к типам, структурам и классам , которую Apple продвигает как реальное изменение парадигм программирования, которое они называют «протокол-ориентированным программированием». (аналогично признакам и классам типов ).

Apple Swift был представлен на Всемирной конференции разработчиков (WWDC) в 2014 году. Он был обновлен до версии 1.2 в 2014 году и серьезно обновлен до Swift 2 на WWDC 2015. Первоначально это был проприетарный язык , но 3 декабря 2015 года версия 2.2 была сделана программным обеспечением с открытым исходным кодом под лицензией Apache 2.0 для платформ Apple. и Линукс .

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

Swift 4.0, выпущенный в 2017 году, внес несколько изменений в некоторые встроенные классы и структуры. Код, написанный с использованием предыдущих версий Swift, можно обновить с помощью функции миграции, встроенной в Xcode. Swift 5, выпущенный в марте 2019 года, представил стабильный двоичный интерфейс на платформах Apple, позволяющий интегрировать среду выполнения Swift в операционные системы Apple. Исходный код совместим со Swift 4.

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

Swift 5.5, официально анонсированный Apple на WWDC 2021 года , значительно расширяет языковую поддержку параллелизма и асинхронного кода , в частности, вводя уникальную версию модели актера .

Swift 5.9 был выпущен в сентябре 2023 года и включает в себя систему макросов, общие пакеты параметров и функции владения, такие как новый consume оператор.

Текущая версия Swift 5.10 была выпущена в марте 2024 года. Эта версия улучшает модель параллелизма языка, обеспечивая полную изоляцию данных для предотвращения гонок за данными . Это также последний выпуск перед Swift 6. Версия 5.10 в настоящее время доступна для macOS, Windows и, в экспериментальном режиме, для Linux.

История

Разработка Swift началась в июле 2010 года Крисом Латтнером с последующим сотрудничеством со многими другими программистами Apple . Свифт был мотивирован необходимостью замены более раннего языка программирования Apple Objective-C , который практически не изменился с начала 1980-х годов и не имел современных языковых функций. Swift взял идеи языка «из Objective-C , Rust , Haskell , Ruby , Python , C# , CLU и многих других, чтобы перечислять их». 2 июня 2014 года приложение Apple Worldwide Developers Conference (WWDC) стало первым публично выпущенным приложением, написанным на Swift. Бета - версия была языка программирования выпущена зарегистрированным разработчикам Apple на конференции, но компания не пообещала, что исходный код финальной версии Swift будет совместим с тестовой версией. Apple планировала предоставить конвертеры исходного кода, если это необходимо для полной версии.

Swift Programming Language , бесплатное 500-страничное руководство, также было выпущено на WWDC и доступно в Apple Books Store и на официальном сайте.

Swift достиг рубежа 1.0 9 сентября 2014 года, получив Gold Master of Xcode 6.0 для iOS . Swift 1.1 был выпущен 22 октября 2014 года одновременно с запуском Xcode 6.1. Swift 1.2 был выпущен 8 апреля 2015 года вместе с Xcode 6.3. Swift 2.0 был анонсирован на WWDC 2015 и стал доступен для публикации приложений в App Store 21 сентября 2015 года. Swift 3.0 был выпущен 13 сентября 2016 года. Swift 4.0 был выпущен 19 сентября 2017 года. Swift 4.1 был выпущен 29 марта 2018 года.

Swift занял первое место в категории «Самый любимый язык программирования» в Stack Overflow 2015. опросе разработчиков и второе место в 2016 году.

3 декабря 2015 г. язык Swift, поддерживающие библиотеки, отладчик и менеджер пакетов были открыты под лицензией Apache 2.0 с исключением библиотеки времени выполнения. и Swift.org был создан для размещения проекта. Исходный код размещен на GitHub , где каждый может легко получить код, собрать его самостоятельно и даже создать запросы на включение, чтобы внести код обратно в проект.

В декабре 2015 года IBM анонсировала свой веб-сайт Swift Sandbox, который позволяет разработчикам писать код Swift на одной панели и отображать выходные данные на другой. Swift Sandbox устарела в январе 2018 года.

Во время WWDC 2016 Apple анонсировала для iPad эксклюзивное приложение под названием Swift Playgrounds , предназначенное для обучения людей программированию на Swift. Приложение представлено в интерфейсе , напоминающем 3D-видеоигру, который обеспечивает обратную связь, когда строки кода располагаются в определенном порядке и выполняются.

В январе 2017 года Крис Латтнер объявил о своем уходе из Apple на новую должность в Tesla Motors , при этом ведущая роль в проекте Swift перешла к ветерану команды Теду Кременеку.

Во время WWDC 2019 Apple анонсировала SwiftUI с Xcode 11, который обеспечивает основу для проектирования декларативной структуры пользовательского интерфейса на всех платформах Apple.

Официальные загрузки дистрибутива Ubuntu Linux доступны начиная с Swift 2.2, а после Swift 5.2.4, CentOS и Amazon Linux добавлено больше дистрибутивов. Также существует неофициальный SDK и собственный пакет инструментов для Android.

Платформы

Платформы, которые поддерживает Swift, — это операционные системы Apple ( Darwin , iOS , iPadOS , macOS , tvOS , watchOS ), Linux , Windows и Android .

Ключевым аспектом дизайна Swift является его способность взаимодействовать с огромным объемом существующего кода Objective-C, разработанного для продуктов Apple за предыдущие десятилетия, таких как Cocoa и Cocoa Touch фреймворки . На платформах Apple Objective-C он связан с библиотекой времени выполнения , которая позволяет C , Objective-C , C++ и Swift в одной программе. запускать код

История версий

Быстрый версия	Дата выпуска	macOS	Линукс	Окна
1.0	9 сентября 2014 г.	Да	Нет	Нет
1.1	22 октября 2014 г.	Да	Нет	Нет
1.2	8 апреля 2015 г.	Да	Нет	Нет
2.0	21 сентября 2015 г.	Да	Нет	Нет
2.1	20 октября 2015 г.	Да	Нет	Нет
2.2	21 марта 2016 г.	Да	Да	Нет
2.2.1	3 мая 2016 г.	Да	Да	Нет
3.0	13 сентября 2016 г.	Да	Да	Нет
3.0.1	28 октября 2016 г.	Да	Да	Нет
3.0.2	13 декабря 2016 г.	Да	Да	Нет
3.1	27 марта 2017 г.	Да	Да	Нет
3.1.1	21 апреля 2017 г.	Да	Да	Нет
4.0	19 сентября 2017 г.	Да	Да	Нет
4.0.2	1 ноября 2017 г.	Да	Да	Нет
4.0.3	5 декабря 2017 г.	Да	Да	Нет
4.1	29 марта 2018 г.	Да	Да	Нет
4.1.1	4 мая 2018 г.	Нет	Да	Нет
4.1.2	31 мая 2018 г.	Да	Да	Нет
4.1.3	27 июля 2018 г.	Нет	Да	Нет
4.2	17 сентября 2018 г.	Да	Да	Нет
4.2.1	30 октября 2018 г.	Да	Да	Нет
4.2.2	4 февраля 2019 г.	Нет	Да	Нет
4.2.3	28 февраля 2019 г.	Нет	Да	Нет
4.2.4	29 марта 2019 г.	Нет	Да	Нет
5.0	25 марта 2019 г.	Да	Да	Нет
5.0.1	18 апреля 2019 г.	Да	Да	Нет
5.0.2	15 июля 2019 г.	Нет	Да	Нет
5.0.3	30 августа 2019 г.	Нет	Да	Нет
5.1	10 сентября 2019 г.	Да	Да	Нет
5.1.1	11 октября 2019 г.	Нет	Да	Нет
5.1.2	7 ноября 2019 г.	Да	Да	Нет
5.1.3	13 декабря 2019 г.	Да	Да	Нет
5.1.4	31 января 2020 г.	Нет	Да	Нет
5.1.5	9 марта 2020 г.	Нет	Да	Нет
5.2	24 марта 2020 г.	Да	Да	Нет
5.2.1	30 марта 2020 г.	Нет	Да	Нет
5.2.2	15 апреля 2020 г.	Да	Да	Нет
5.2.3	29 апреля 2020 г.	Нет	Да	Нет
5.2.4	20 мая 2020 г.	Да	Да	Нет
5.2.5	5 августа 2020 г.	Нет	Да	Нет
5.3	16 сентября 2020 г.	Да	Да	Да
5.3.1	13 ноября 2020 г.	Да	Да	Да
5.3.2	15 декабря 2020 г.	Да	Да	Да
5.3.3	25 января 2021 г.	Нет	Да	Да
5.4	26 апреля 2021 г.	Да	Да	Да
5.4.1	25 мая 2021 г.	Нет	Да	Да
5.4.2	28 июня 2021 г.	Да	Да	Да
5.4.3	9 сентября 2021 г.	Нет	Да	Да
5.5	20 сентября 2021 г.	Да	Да	Да
5.5.1	27 октября 2021 г.	Да	Да	Да
5.5.2	14 декабря 2021 г.	Да	Да	Да
5.5.3	9 февраля 2022 г.	Нет	Да	Да
5.6	14 марта 2022 г.	Да	Да	Да
5.6.1	9 апреля 2022 г.	Нет	Да	Да
5.6.2	15 июня 2022 г.	Нет	Да	Да
5.6.3	2 сентября 2022 г.	Нет	Да	Да
5.7	12 сентября 2022 г.	Да	Да	Да
5.7.1	1 ноября 2022 г.	Да	Да	Да
5.8	30 марта 2023 г.	Да	Да	Да
5.8.1	1 июня 2023 г.	Да	Да	Да
5.9	18 сентября 2023 г.	Да	Да	Да
5.9.1	19 октября 2023 г.	Да	Да	Да
5.9.2	11 декабря 2023 г.	Да	Да	Да
5.10	5 марта 2024 г.	Да	Да	Да

Особенности

Swift — это язык программирования общего назначения, который использует современные концепции теории языков программирования и стремится предоставить простой, но мощный синтаксис. Swift включает в себя инновации и традиции различных языков программирования, в том числе и Objective-C, который он заменил в качестве основного языка разработки на платформах Apple.

Swift был разработан, чтобы быть безопасным и дружелюбным для новых программистов, не жертвуя при этом скоростью. По умолчанию Swift автоматически управляет всей памятью и гарантирует, что переменные всегда инициализируются перед использованием. Доступ к массиву проверяется на наличие ошибок выхода за пределы, а целочисленные операции проверяются на переполнение. Имена параметров позволяют создавать понятные API. Протоколы определяют интерфейсы, которые могут использовать типы, а расширения позволяют разработчикам добавлять больше функций к существующим типам. Swift обеспечивает объектно-ориентированное программирование с поддержкой классов , подтипов и переопределения методов . Опциональные параметры позволяют нулевые явно и безопасно обрабатывать значения. Параллельные программы могут быть написаны с использованием async/await синтаксиса , а актеры изолируют общее изменяемое состояние, чтобы исключить гонки данных.

Основной синтаксис

Swift Синтаксис аналогичен синтаксису языков C. По умолчанию код начинает выполняться в глобальной области. Альтернативно, @main К атрибуту можно применить объявление структуры, класса или перечисления, чтобы указать, что он содержит точку входа в программу.

Свифта. «Привет, мир!» программа это:

print  (  «Привет, мир!»  ) 

The print(_:separator:terminator:)Используемая здесь функция включена в стандартную библиотеку Swift, которая доступна всем программам без необходимости импорта внешних модулей. Операторы в Swift не обязательно должны заканчиваться точкой с запятой, однако точки с запятой необходимы для разделения нескольких операторов, написанных в одной строке. Однострочные комментарии начинаются с //и продолжайте до конца текущей строки. Многострочные комментарии содержатся в /* и */персонажи. Константы объявляются с помощью let ключевое слово и переменные с помощью varключевое слово. Значения должны быть инициализированы перед их чтением. Значения могут определять свой тип на основе типа предоставленного начального значения. Если начальное значение установлено после объявления значения, тип должен быть объявлен явно.

let   highScoreThreshold   =   1000   // Константа типа Int.   Тип был выведен на основе предоставленного значения. 

  var   currentScore   =   980   // Переменная типа Int. 
  currentScore   =   1200   // Значение переменных может меняться со временем. 

  let   playerMessage  :   String   // Константа с явным типом String. 
  if   currentScore   >   highScoreThreshold   { 
     playerMessage   =   "Вы лучший игрок!" 
  }   else   { 
     playerMessage   =   "В следующий раз повезет." 
  } 

 print  (  playerMessage  )   // Печатает «Вы лучший игрок!» 

Поток управления в Swift управляется с помощью операторов if-else , Guard и Switch , а также циклов while и for-in . Операторы if принимают логический параметр и выполняют тело оператора if, если условие истинно, в противном случае выполняется необязательный оператор if. else тело. if-let Синтаксис предоставляет синтаксический сахар для проверки существования необязательного значения и одновременной его развертывания.

let   someNumber   =   42 
 if   someNumber   %   2   ==   0   {   // Используйте оператор остатка, чтобы найти остаток someNumber, разделенный на 2. 
     print  (  "  \(  someNumber  )  четно."  ) 
 }   else  { 
    print  (  "  \(  someNumber  )  нечетно."  ) 
 } 

 // Печатает "42 четно." 

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

funcstructGreeting   !  (  for   name  :   String  )   ->   String   { 
     return   "Hello  \(  name  )  " 
  } 

 let   Greeting   =   конструктивGreeting  (  for  :   "Крейг"  ) 

 print  (  приветствие  )   // Печатает "Привет, Крейг!" 

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

func   diveByTwo  (  _   aNum  :   Int  )   ->   Int   { 
     return   aNum   /   2 
 } 

 func   MultiByTwo  (  _   aNum  :   Int  )   ->   Int   { 
     return   aNum   *   2 
 } 

 let   mathOperation   =   MultipleByTwo 

 print  (  mathOperation  (  21  ))   // Печатает "42" " 

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

функция   деления  (  числитель  :   Int  ?,   знаменатель на знаменатель   :  Int   )  -   >   Int  ?    { 
     Guard   denominator   !=   0   else   { 
         print  (  "Невозможно разделить на 0."  ) 
         return   nil 
     } 
    
     Guard   let   numerator   else   { 
         print  (  "Указанный числитель равен нулю."  ) 
         return   nil 
     } 
    
     return   числитель   /   знаменатель 
 } 

 let   result   =   разделить  (  numerator  :   3  ,   byDenominator  :   0  ) 
 print  (  «Результат деления:  \(  result  )  »  ) 

 // Печатает: 
 // «Невозможно разделить на 0». 
  // «Результат деления: ноль». 

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

let   someNumber   =   42 

 switch   someNumber   { 
 case   ..<  0  :  
     print  (  "  \(  someNumber  )  отрицательный."  ) 
 case   0  :  
     print  (  "  \(  someNumber  )  равно 0."  ) 
 case   1  ...  9  : 
     print  (  "  \ (  someNumber  )  больше 0, но меньше 10."  ) 
 default  :  
     print  (  "  \(  someNumber  )  больше 9."  ) 
 } 

 // Печатает "42 больше 9." 

for-in циклы перебирают последовательность значений:

let   Names   =   [  "Will"  ,   "Anna"  ,   "Bart"  ] 
 for   name   in   Names   { 
     print  (  name  ) 
 } 
 // Печатает: 
 // Will 
 // Анна 
 // Барт 

while циклы повторяются до тех пор, пока данное логическое условие оценивается как true:

// Складываем все числа от 1 до 5. 
 var   i   =   1 
 var   result   =   0 

 while   i   <=   5   {   // Цикл выполняет свое тело до тех пор, пока i меньше или равно 5. 
     result   +=   i   / / Добавить i к текущему результату. 
      i   +=   1   // Увеличиваем i на 1. 
 } 

 print  (  result  )   // Печатает «15» 

Поддержка закрытия

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

// Тип замыкания, определяемый входными и выходными значениями, может быть указан вне замыкания: 
 let   closure1  :   (  Int  ,   Int  )   ->   Int   =   {   arg1  ,   arg2   в 
     return   arg1   +   arg2 
 } 

 // … или внутри него: 
 let   closure2   =   {   (  arg1  :   Int  ,   arg2  :   Int  )   ->   Int   в 
     return   arg1   +   arg2 
 } 

 // В большинстве случаев тип возвращаемого значения замыкания может быть определен автоматически компилятором. 
  let   closure3   =   {   arg1  :   Int  ,   arg2  :   Int   взамен 
    ​   arg1   +   arg2 
 } 

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

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

// Эта функция принимает замыкание, которое не получает входных параметров, и возвращает целое число, 
 // оценивает его и использует возвращаемое значение замыкания (Int) в качестве возвращаемого значения функции. 
  func   foo  (  closure   bar  :   ()   ->   Int  )   ->   Int   { 
     return   bar  () 
 } 

 // Без завершающего синтаксиса замыкания: 
 foo  (  closure  :   {   return   1   }) 

 // С завершающим синтаксисом замыкания и неявным возвратом: 
 foo   {   1   } 

Начиная с версии 5.3, Swift поддерживает несколько замыканий:

// Эта функция передает возврат первого замыкания в качестве параметра второго 
 // и возвращает результат второго замыкания: 
 func   foo  (  bar  :   ()   ->   Int  ,   baz  :   (  Int  )   ->   Int  )   ->   Int   { 
     return   baz  (  bar  ()) 
 } 

 // Без замыканий: 
 foo  (  bar  :   {   return   1   },   baz  :   {   x   in   return   x   +   1   }) 

 // С 1 замыканием: 
 foo  (  bar  :   {   return   1   })   {   x   in   return   x   +   1   } 

 // С двумя замыкающими замыканиями (опущено только имя аргумента первого замыкания): 
 foo   {   return   1   }   baz  :   {   x   in   return   x   +   1   } 

Swift предоставит сокращенные имена аргументов для встроенных замыканий, устраняя необходимость явно называть все параметры замыканий. К аргументам можно обращаться с именами $0, $1, $2 и т. д.:

let   names   =   [  "Жозефина"  ,   "Стив"  ,   "Крис"  ,   "Барбара"  ] 

 // фильтр вызывает данное замыкание для каждого значения в именах. 
  // Значения с количеством символов меньше 6 сохраняются, остальные удаляются. 
  пусть   shortNames   =   имена  .   фильтр   {   $0  .   count   <   6   } 

 print  (  shortNames  )   // Печатает "["Стив", "Крис"]" 

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

func   makeMultiplier  (  withMultiple   Multiple  :   Int  )   ->   (  Int  )   ->   (  Int  )   { 
     // Создаем и возвращаем замыкание, которое принимает Int и возвращает входные данные, умноженные на значение Multiple. 
      return   { 
         $0   *   Multiple 
     } 
 } 

 let   multiplier   =   makeMultiplier  (  withMultiplier  :   3  ) 
 print  (  multiplier  (  3  ))   // Печатает «9» 
 print  (  multiplier  (  10  ))   // Печатает «30» 

Поддержка строк

Стандартная библиотека Swift включает в себя юникод-совместимую String и Characterтипы. Строковые значения могут быть инициализированы строковым литералом — последовательностью символов, заключенной в двойные кавычки. Строки могут быть объединены с помощью + оператор:

var   someString   =   "Привет", 
 someString   +=   "мир!" 

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

var   currentScore   =   980 
 print  (  «Ваша оценка  \(  currentScore  )  ».  ) 

 // Печатает «Ваша оценка 980». 

Цикл for-in можно использовать для перебора символов, содержащихся в строке:

для   символа   в   "Swift"   { 
     print  (  character  ) 
 } 
 // S 
 // w 
 // i 
 // f 
 // t 

Когда платформа Foundation импортируется, Swift незаметно связывает тип String с NSString, классом String, обычно используемым в Objective-C.

Вызываемые объекты

Этот раздел представляет собой отрывок из Callable object § In Swift . [ редактировать ]

В Swift вызываемые объекты определяются с помощью callAsFunction.

struct   CallableStruct   { 
     var   значение  :   Int 
     func   callAsFunction  (  _   число  :   Int  ,   масштаб  :   Int  )   { 
         print  (  масштаб   *   (  число   +   значение  )) 
     } 
 } 
 let   callable   =   CallableStruct  (  значение  :   100  ) 
 вызываемый  (  4  ,   масштаб  :   2  ) 
 вызываемый  .   callAsFunction  (  4  ,   Scale  :   2  ) 
 // Оба вызова функции печатают 208. 

Контроль доступа

Swift поддерживает пять уровней контроля доступа к символам: open, public, internal, fileprivate, и private. В отличие от многих объектно-ориентированных языков, эти средства управления доступом игнорируют наследования : иерархии private указывает, что символ доступен только в непосредственной области видимости , fileprivate указывает, что он доступен только изнутри файла, internal указывает, что он доступен внутри содержащего модуля, public указывает, что он доступен из любого модуля, и open (только для классов и их методов) указывает, что класс может быть подклассом вне модуля.

Опционы и цепочка

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

Необязательные типы создаются с помощью Optionalперечисление. Чтобы сделать целое число, допускающее значение NULL, можно было бы использовать объявление, подобное var optionalInteger: Optional<Int>. Как и в С#, Swift также включает для этого синтаксический сахар, позволяющий указать, что переменная является необязательной, поставив вопросительный знак после имени типа. var optionalInteger: Int?. Переменные или константы, помеченные как необязательные, либо имеют значение базового типа, либо являются необязательными. nil. Необязательные типы оборачивают базовый тип, в результате чего создается другой экземпляр. String и String? это принципиально разные типы, первый относится к типу String в то время как последний является Optional это может содержать некоторые String ценить.

Чтобы получить доступ к значению внутри, предполагая, что оно не равно нулю, его необходимо развернуть , чтобы открыть экземпляр внутри. Это выполняется с помощью ! оператор:

пусть   myValue   =   anOptionalInstance  !.   некоторыйМетод  () 

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

пусть   myValue   =   anOptionalInstance  ?.   некоторыйМетод  () 

В этом случае среда выполнения вызывает someMethod только если anOptionalInstanceне равно нулю, что подавляет ошибку. А ?должен быть помещен после каждого необязательного свойства. Если какое-либо из этих свойств равно нулю, все выражение оценивается как ноль. Происхождение термина « цепочка» происходит от более распространенного случая, когда несколько вызовов/геттеров методов связаны вместе. Например:

пусть   aTenant   =   aBuilding  .   tenantList  [  5  ] 
 пусть   их Lease   =   aTenant  .   LeaseDetails 
 let   LeaseStart   =   их Lease  ?.   Дата начала 

можно свести к:

пусть   LeaseStart   =   aBuilding  .   список арендаторов  [  5  ].   арендаПодробнее  ?.   Дата начала 

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

Типы значений

Во многих объектно-ориентированных языках объекты внутренне представлены двумя частями. Объект хранится как блок данных, помещенный в кучу , а имя (или «дескриптор») этого объекта представлено указателем . Объекты передаются между методами путем копирования значения указателя, что позволяет любому, у кого есть копия, получить доступ к одним и тем же базовым данным в куче. Напротив, базовые типы, такие как целые числа и значения с плавающей запятой, представляются напрямую; дескриптор содержит данные, а не указатель на них, и эти данные передаются непосредственно методам путем копирования. Эти стили доступа называются передачей по ссылке в случае объектов и передачей по значению для базовых типов.

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

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

Программист волен выбирать, какая семантика больше подходит для каждой структуры данных в приложении. Более крупные структуры, такие как окна, будут определяться как классы, что позволит передавать их как указатели. Меньшие структуры, такие как 2D-точка, могут быть определены как структуры, которые будут передаваться по значению и позволять прямой доступ к своим внутренним данным без косвенности или подсчета ссылок. Улучшение производительности, свойственное концепции передачи по значению, таково, что Swift использует эти типы почти для всех распространенных типов данных, включая Int и Doubleи типы, обычно представляемые объектами, например String и Array. Использование типов значений также может привести к значительному повышению производительности пользовательских приложений.

Array, Dictionary, и Setвсе они используют копирование при записи, так что их данные копируются только тогда, когда программа пытается изменить в них значение. Это означает, что различные методы доступа имеют фактически указатель на одно и то же хранилище данных. Таким образом, хотя данные физически хранятся в памяти как один экземпляр, на уровне приложения эти значения являются отдельными, и физическое разделение осуществляется путем копирования при записи только в случае необходимости.

Расширения

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

Расширения объявляются с помощью extension ключевое слово.

struct   Rectangle   { 
     let   width  :   Double 
     let   height  :   Double 
 } 

 Extension   Rectangle   { 
     var   area  :   Double   { 
         возвращаемая   высота   *   ширина 
     } 
 } 

Протокольно-ориентированное программирование

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

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

Например, протокол может быть объявлен с именем Printable, который гарантирует, что экземпляры, соответствующие протоколу, реализуют description имущество и printDetails() требование метода:

// Определить протокол с именем Printable 
 протокол   Printable   { 
     var   описание  :   String   {   get   }   // Требование к свойству только для чтения 
     func   printDetails  ()   // Требование к методу 
 } 

Этот протокол теперь может быть принят другими типами:

// Принятие протокола Printable в классе 
 class   MyClass  :   Printable   { 
     var   описание  :   String   { 
         return   "Экземпляр MyClass" 
     } 

     func   printDetails  ()   { 
         print  (  description  ) 
     } 
 } 

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

Extension   Printable   {   // Все экземпляры Printable получат эту реализацию или могут определить свою собственную. 
      func   printDetails  ()   { 
         print  (  description  ) 
     } 
 } 

 // Bool теперь соответствует Printable и наследует реализацию printDetails(), указанную выше. 
  расширение   Bool  :   Printable   { 
     var   описание  :   String   { 
         return   "Экземпляр Bool со значением:  \(  self  )  " 
     } 

 } 

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

func   getSomethingPrintable  ()   >   Any   Printable   { 
     return   true 
 } 

 var   someSortOfPrintableInstance   =   getSomethingPrintable  () 
 print  (  someSortOfPrintableInstance.description  -  »  ) 

 // Печатает «Экземпляр Bool со значением: true 

Не имеет значения, какой конкретный тип someSortOfPrintableInstanceТо есть компилятор гарантирует, что он соответствует протоколу и, следовательно, этот код безопасен. Этот синтаксис также означает, что коллекции также могут быть основаны на протоколах, например let printableArray = [any Printable].

И расширения, и протоколы широко используются в стандартной библиотеке Swift; в Swift 5.9 примерно 1,2 процента всех символов в стандартной библиотеке были протоколами, а еще 12,3 процента были требованиями протокола или реализациями по умолчанию. Например, Swift использует расширения для добавления Equatable протокол для многих их основных типов, таких как строки и массивы, что позволяет сравнивать их с ==оператор. Equatable протокол также определяет эту реализацию по умолчанию:

func   !=<  T   :   Equatable  >(  левая часть  :   T  ,   правая часть  :   T  )   ->   Bool 

Эта функция определяет метод, который работает с любым экземпляром, соответствующим Equatable, предоставляя оператор равенства . Любой экземпляр, класс или структура автоматически получает эту реализацию, просто соответствуя Equatable.

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

расширение   Array   , где   Element  :   Equatable   { 

     // allEqual будет доступно только в экземплярах Array, содержащих элементы Equatable. 
      func   allEqual  ()   ->   Bool   { 
         for   element   in   self   { 
             if   element   !=   self  .   сначала   { 
                 return   false 
             } 
         } 
         return   true 
     } 
 } 

Параллельность

Swift 5.5 представил в языке структурированный параллелизм. Структурированный параллелизм использует синтаксис Async/await , аналогичный Kotlin, JavaScript и Rust. Асинхронная функция определяется с помощью asyncключевое слово после списка параметров. При вызове асинхронной функции awaitКлючевое слово должно быть записано перед функцией, чтобы указать, что выполнение потенциально может быть приостановлено при вызове функции. Пока функция приостановлена, программа может одновременно запускать другую функцию в той же программе. Этот синтаксис позволяет программам четко определять потенциальные точки приостановки и избегать версии « Пирамиды гибели» (программирование), вызванной ранее широко распространенным использованием обратных вызовов закрытия.

func   downloadText  (  name  :   String  )   async   ->   String   { 
     let   result   =   // ... некоторый код асинхронной загрузки ... 
     возвращаем   результат 
 } 

 let   text   =   await   downloadText  (  «text1»  ) 

The async let синтаксис позволяет нескольким функциям выполняться параллельно. await снова используется для обозначения точки, в которой программа приостанавливает ожидание завершения async функции, вызванные ранее.

// Каждый из этих вызовов downloadText будет выполняться параллельно. 
  async   let   text1   =   downloadText  (  name  :   "text1"  ) 
 async   let   text2   =   downloadText  (  name  :   "text2"  ) 
 async   let   text3   =   downloadText  (  name  :   "text3"  ) 

 let   textToPrint   =   await   [  text1  ,   text2  ,   text3  ]   // Приостанавливается пока все три вызова downloadText не вернутся. 
  печать  (  textToPrint  ) 

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

let   TaskHandle   =   Задача   { 
     ждут   downloadText  (  имя  :   "someText"  ) 
 } 

 let   result   =   ждут   TaskHandle  .   ценить 

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

 актера  Каталог   { 
     var   name  :   [  String  ]   =   [] 
    
     func   add  (  name  :   String  )   { 
         names  .   append  (  name  ) 
     } 
 } 

 letdirectory   // Код приостанавливается ,   =   Directory  () 

 пока другие задачи не завершат доступ к актеру. 
  жду   каталог  .   добавить  (  имя  :   «Такер»  ) 
 печать  (  ожидание   каталога  .  имена  ) 

Библиотеки, среда выполнения, разработка

В системах Apple Swift использует ту же среду выполнения, что и существующая система Objective-C , но требует iOS 7 или macOS 10.9 или выше. Это также зависит от Grand Central Dispatch . Код Swift и Objective-C можно использовать в одной программе, а также, как следствие, C и C++. Начиная с Swift 5.9, код C++ можно использовать непосредственно из кода Swift. В случае Objective-C Swift имеет значительный доступ к объектной модели и может использоваться для создания подклассов, расширения и использования кода Objective-C для обеспечения поддержки протокола. Обратное неверно: класс Swift не может быть подклассом в Objective-C.

Чтобы помочь в разработке таких программ и повторном использовании существующего кода, Xcode 6 и выше предлагает полуавтоматическую систему, которая создает и поддерживает связующий заголовок для предоставления кода Objective-C Swift. Это принимает форму дополнительного файла заголовка , который просто определяет или импортирует все символы Objective-C, необходимые для кода Swift проекта. В этот момент Swift может ссылаться на типы, функции и переменные, объявленные в этом импорте, как если бы они были написаны на Swift. Код Objective-C также может напрямую использовать код Swift путем импорта автоматически поддерживаемого заголовочного файла с объявлениями Objective-C символов Swift проекта. Например, файл Objective-C в смешанном проекте под названием «MyApp» может получить доступ к классам или функциям Swift с помощью кода #import "MyApp-Swift.h". Однако не все символы доступны через этот механизм — использование специфичных для Swift функций, таких как универсальные типы, необъектные дополнительные типы, сложные перечисления или даже идентификаторы Unicode, может сделать символ недоступным из Objective-C.

Swift также имеет ограниченную поддержку атрибутов — метаданных, которые считываются средой разработки и не обязательно являются частью скомпилированного кода. Как и Objective-C, атрибуты используют @синтаксис, но доступный в настоящее время набор невелик. Одним из примеров является @IBOutletатрибут, который помечает данное значение в коде как выход , доступный для использования в Interface Builder (IB). Розетка — это устройство , которое привязывает значение экранного дисплея к объекту в коде.

В системах сторонних производителей Swift не зависит от среды выполнения Objective-C или других системных библиотек Apple; их заменяет набор реализаций Swift «Corelib». К ним относятся «swift-corelibs-foundation», заменяющий Foundation Kit , «swift-corelibs-libdispatch», заменяющий Grand Central Dispatch, и «swift-corelibs-xctest», заменяющий XCTest. API из Xcode .

Начиная с 2019 года, в Xcode 11, Apple также добавила новую важную парадигму пользовательского интерфейса под названием SwiftUI. SwiftUI заменяет старую парадигму Interface Builder новой парадигмой декларативной разработки.

Управление памятью

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

Цикл сильной ссылки может возникнуть, если каждый из двух экземпляров сильно ссылается друг на друга (например, A ссылается на B, B ссылается на A). Поскольку ни один из экземпляров счетчика ссылок никогда не может достичь нуля, ни один экземпляр никогда не освобождается, что приводит к утечке памяти . Swift предоставляет ключевые слова weak и unownedдля предотвращения сильных эталонных циклов. Эти ключевые слова позволяют ссылаться на экземпляр без увеличения счетчика ссылок. weak ссылки должны быть необязательными переменными, поскольку они могут изменяться и становиться nil. Попытка получить доступ к unowned значение, которое уже было освобождено, приводит к ошибке времени выполнения.

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

класс   Person   { 
     let   name  :   String 
     слабый   var   home  :   Home  ?    // Определяется как слабая ссылка, чтобы разорвать цикл ссылок.   слабые ссылки не увеличивают счетчик ссылок экземпляра, на который они ссылаются. 
    
      init  (  имя  :   Строка  )   { 
         self  .   name   =   name 
     } 
    
     deinit   {   print  (  "Деинициализировано  \(  name  )  "  )   } 
 } 

 class   Home   { 
     let   адрес  :   String 
     var   Owner  :   Person  ? 
    
      init  (  адрес  :   строка  ,   владелец  :   человек  ?)   { 
         self  .   адрес   =   адрес 
         самого себя  .   владелец   =   владелец 
     } 
    
     deinit   {   print  (  «Деинициализировано  \(  адрес  )  »  )   } 
 } 

 var   stacy  :   Person  ?    =   Человек  (  имя  :   «Стейси»  ) 
 var   house21b  :   Дом  ?    =   Дом  (  адрес  :   «Бейкер-стрит, 21б»  ,   владелец  :   Стейси  ) 

 Стейси  ?.   home   =   house21b   // Стейси и house42b теперь ссылаются друг на друга. 

  stacy   =   nil   // Счетчик ссылок на Stacy теперь равен 1, поскольку house21b все еще содержит ссылку на нее. 
  house21b   =   nil   // счетчик ссылок house21b падает до 0, что, в свою очередь, снижает счетчик ссылок stacy до 0, поскольку house21b был последним экземпляром, содержащим сильную ссылку на stacy. 

  // Печатает: 
 // Деинициализированная улица Бейкер-стрит, 21б 
 // Деинициализированная Стейси 

Отладка

Ключевым элементом системы Swift является ее способность четко отлаживаться и запускаться в среде разработки с использованием цикла чтения-оценки-печати (REPL), что придает ей интерактивные свойства, больше похожие на возможности написания сценариев Python, чем на традиционное системное программирование. языки. REPL дополнительно расширен за счет игровых площадок , интерактивных представлений, работающих в среде Xcode или приложения Playgrounds , которые оперативно реагируют на изменения кода или отладчика. Playgrounds позволяют программистам добавлять код Swift вместе с документацией по уценке. Программисты могут поэтапно выполнять код и добавлять точки останова с помощью LLDB либо в консоли, либо в среде IDE , такой как Xcode.

Сравнения с другими языками

Swift считается языком программирования семейства C и во многом похож на C:

• Большинство операторов C также присутствуют в Swift, хотя некоторые операторы, такие как +имеют немного другое поведение. Например, в Swift + ловушки при переполнении, тогда как &+ используется для обозначения C-подобного поведения переноса при переполнении.
• Фигурные скобки используются для группировки операторов.
• Переменные присваиваются с использованием знака равенства , но сравниваются с использованием двух последовательных знаков равенства . Новый оператор идентификации, ===, предназначен для проверки того, относятся ли два элемента данных к одному и тому же объекту .
• Управляющие операторы while, if, и switch похожи, но имеют расширенные функции, например, switch который принимает нецелые случаи, while и if поддержка сопоставления с образцом и условной развертки опций, for использует for i in 1...10 синтаксис.
• Квадратные скобки используются с массивами как для их объявления, так и для получения значения по заданному индексу в одном из них.

Он также имеет сходство с Objective-C:

• Основные числовые типы: Int, UInt, Float, Double
• Методы класса наследуются, как и методы экземпляра; self в методах класса — это класс, в котором был вызван метод.
• Похожий for... in синтаксис перечисления.

Отличия от Objective-C включают в себя:

• Операторы не обязательно должны заканчиваться точкой с запятой ( ;), хотя их необходимо использовать, чтобы разрешить использование более одного оператора в одной строке.
• Нет заголовочных файлов.
• Использует вывод типа .
• Общее программирование .
• Функции являются объектами первого класса .
• Случаи перечисления могут иметь связанные данные ( алгебраические типы данных ).
• Для классов можно переопределить операторы ( перегрузка операторов ), а также определить новые операторы.
• Строки полностью поддерживают Unicode . Большинство символов Юникода можно использовать как в идентификаторах, так и в операторах.
• Никакой обработки исключений . Swift 2 представляет другую и несовместимую модель обработки ошибок.
• Некоторые функции более ранних языков семейства C , которыми легко злоупотреблять, были удалены:
  • Указатели по умолчанию не отображаются. Программисту нет необходимости отслеживать и помечать имена для ссылки или разыменования.
  • Присвоения не возвращают значения. Это предотвращает распространенную ошибку записи i = 0 вместо i == 0 выдавая ошибку времени компиляции.
  • Нет необходимости использовать break заявления в switchблоки. Отдельные случаи не переходят в следующий случай, если только fallthrough используется заявление.
  • Переменные и константы всегда инициализируются, а границы массива всегда проверяются.
  • Переполнение целых чисел , которое приводит к неопределенному поведению целых чисел со знаком в C, перехватывается как ошибка времени выполнения в Swift. Программисты могут разрешить переполнение, используя специальные арифметические операторы. &+, &-, &*, &/ и &%. Свойства min и max определены в Swift для всех целочисленных типов и могут использоваться для безопасной проверки потенциальных переполнений вместо использования констант, определенных для каждого типа во внешних библиотеках.
  • Однозначная форма if и while, позволяющий опускать скобки вокруг оператора, не поддерживается.
  • Перечисление в стиле C for (int i = 0; i < c; i++), который подвержен ошибкам отклонения на единицу , не поддерживается (начиная с Swift 3).
  • Операторы пре- и пост- инкремента и декремента ( i++, --i ...) не поддерживаются (начиная с Swift 3), тем более что в стиле C for утверждения также не поддерживаются, начиная с Swift 3.

Разработка и другие реализации

Поскольку Swift может работать в Linux, иногда его также используют в качестве серверного языка. Некоторые веб-фреймворки уже разработаны, например IBM от Kitura (сейчас производство прекращено), Perfect и Vapor .

Apple также создала официальную рабочую группу «Server APIs». центральную роль играют члены сообщества разработчиков Swift.

Вторая бесплатная реализация Swift, ориентированная на , Microsoft Common Cocoa Language Infrastructure ( .NET Framework , теперь .NET ), а также на платформы Java и Android , существует как часть компилятора Elements от RemObjects Software .

Подмножества Swift были портированы на дополнительные платформы, такие как Arduino. и Mac OS 9 .

См. также

• Сравнение языков программирования
• Цель-C
• D (язык программирования)
• Котлин (язык программирования)
• Python (язык программирования)
• Ним (язык программирования)

Внешние ссылки

• Официальный веб-сайт
• Свифт в Apple Developer
• Исходный код Swift на GitHub
• Быстрый пример
• Серверный Swift: Vapor Framework