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

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

Быстрый
Swift logo.svg Логотип
Парадигма Мультипарадигма : протокольно-ориентированная, объектно-ориентированная, функциональная, императивная, блочно-структурированная, декларативная.
Разработано Крис Латтнер, Дуг Грегор, Джон Макколл, Тед Кременек, Джо Грофф и Apple Inc.
Разработчик Apple Inc. и участники с открытым исходным кодом
Впервые появился 2 июня 2014 г. ; 7 лет назад ( 2014-06-02)
Стабильный выпуск 5.4.2  Отредактируйте это в Викиданных / 28 июня 2021 г. ; 3 месяца назад ( 28 июня 2021 г.)
Предварительный выпуск 5.5 филиал
Печатная дисциплина Статичный, сильный, предполагаемый
Операционные системы Операционные системы Apple ( Darwin, iOS, iPadOS, macOS, tvOS, watchOS ), Linux, Windows 10, Android
Лицензия Лицензия Apache License 2.0 (Swift 2.2 и новее) Собственная (до Swift 2.2)
Расширения имени файла .swift,.SWIFT
Веб-сайт быстрый.org
Под влиянием
Objective-C, Rust, Haskell, Ruby, Python, C #, CLU, D
Под влиянием
Ржавчина

Swift является универсальным, несколько парадигм, составленный язык программирования, разработанный Apple Inc. и с открытым исходным кодом сообщества. Впервые выпущенный в 2014 году, Swift был разработан как замена более раннему языку программирования Apple Objective-C, поскольку Objective-C практически не изменился с начала 1980-х годов и не имел современных языковых функций. Swift работает с фреймворками Apple Cocoa и Cocoa Touch, и ключевым аспектом дизайна Swift была способность взаимодействовать с огромным объемом существующего кода Objective-C, разработанного для продуктов Apple за предыдущие десятилетия. Он построен на платформе компилятора LLVM с открытым исходным кодом и включен в Xcode с версии 6, выпущенной в 2014 году. На платформах Apple он использует библиотеку времени выполнения Objective-C, которая позволяет коду C, Objective-C, C ++ и Swift работать в рамках одной программы.

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

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

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

СОДЕРЖАНИЕ

  • 1 История
    • 1.1 Платформы
    • 1.2 История версий
  • 2 Особенности
    • 2.1 Поддержка закрытия
    • 2.2 Поддержка строк
    • 2.3 Контроль доступа
    • 2.4 Опции и цепочки
    • 2.5 Типы значений
    • 2.6 Протоколно-ориентированное программирование
    • 2.7 Библиотеки, среда выполнения и разработка
    • 2.8 Управление памятью
    • 2.9 Отладка и другие элементы
    • 2.10 Производительность
  • 3 Сравнение с другими языками
  • 4 Разработка и другие реализации
  • 5 См. Также
  • 6 Ссылки
  • 7 Внешние ссылки

История

Разработка Swift началась в июле 2010 года Крисом Латтнером при возможном сотрудничестве со многими другими программистами Apple. 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 в Xcode 6.0 для прошивки. 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. Приложение представлено в виде интерфейса, похожего на трехмерную видеоигру, который обеспечивает обратную связь, когда строки кода размещаются в определенном порядке и выполняются.

В январе 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.

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

Версия Дата выхода macOS Linux Окна
Swift 1.0 9 сентября 2014 г. да Нет Нет
Swift 1.1 22 октября 2014 г. да Нет Нет
Swift 1.2 8 апреля 2015 г. да Нет Нет
Swift 2.0 21 сентября 2015 г. да Нет Нет
Swift 2.1 20 октября 2015 г. да Нет Нет
Swift 2.2 21 марта 2016 г. да да Нет
Swift 2.2.1 3 мая 2016 г. да да Нет
Swift 3.0 13 сентября 2016 г. да да Нет
Swift 3.0.1 28 октября 2016 г. да да Нет
Swift 3.0.2 13 декабря 2016 г. да да Нет
Swift 3.1 27 марта 2017 г. да да Нет
Swift 3.1.1 21 апреля 2017 г. да да Нет
Swift 4.0 19 сентября 2017 г. да да Нет
Swift 4.0.2 1 ноября 2017 г. да да Нет
Swift 4.0.3 5 декабря 2017 г. да да Нет
Swift 4.1 29 марта 2018 г. да да Нет
Swift 4.1.1 4 мая 2018 г. Нет да Нет
Swift 4.1.2 31 мая 2018 г. да да Нет
Swift 4.1.3 27 июля 2018 г. Нет да Нет
Swift 4.2 17 сентября 2018 г. да да Нет
Swift 4.2.1 30 октября 2018 г. да да Нет
Swift 4.2.2 4 февраля 2019 г., Нет да Нет
Swift 4.2.3 28 февраля 2019 г., Нет да Нет
Swift 4.2.4 29 марта 2019 г., Нет да Нет
Swift 5.0 25 марта 2019 г., да да Нет
Swift 5.0.1 18 апреля 2019 г., да да Нет
Swift 5.0.2 15 июля 2019 г., Нет да Нет
Swift 5.0.3 30 августа 2019 г., Нет да Нет
Swift 5.1 10 сентября 2019 г., да да Нет
Swift 5.1.1 11 октября 2019 г., Нет да Нет
Swift 5.1.2 7 ноября 2019 г., да да Нет
Swift 5.1.3 13 декабря 2019 г., да да Нет
Swift 5.1.4 31 января 2020 г. Нет да Нет
Swift 5.1.5 9 марта 2020 г. Нет да Нет
Swift 5.2 24 марта 2020 г. да да Нет
Swift 5.2.1 30 марта 2020 г. Нет да Нет
Swift 5.2.2 15 апреля 2020 г. да да Нет
Swift 5.2.3 29 апреля 2020 г. Нет да Нет
Swift 5.2.4 20 мая, 2020 да да Нет
Swift 5.2.5 5 августа 2020 г. Нет да Нет
Swift 5.3 16 сентября 2020 г. да да да
Swift 5.3.1 13 ноября 2020 г. да да да
Swift 5.3.2 15 декабря 2020 г. да да да
Swift 5.3.3 25 января 2021 г. Нет да да
Swift 5.4 26 апреля 2021 г. да да да
Swift 5.4.1 25 мая 2021 г. Нет да да
Swift 5.4.2 28 июня 2021 г. да да да
Swift 5.4.3 9 сентября 2021 г. Нет да да
Swift 5.5 20 сентября 2021 г. да да да

Функции

Swift - альтернатива языку Objective-C, который использует современные концепции теории языков программирования и стремится представить более простой синтаксис. Во время своего появления он был описан просто как «Objective-C без багажа C».

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

Закрытие поддержки

Swift поддерживает замыкания (известные как лямбды на других языках). Замыкания - это автономные функциональные блоки, которые можно передавать и использовать в вашем коде. Замыкания можно рассматривать как безымянную функцию. Вот пример:

// Closure type, defined by its input and output values, can be specified outside the closure: let closure1: (Int, Int) -gt; Int = { arg1, arg2 in  return arg1 + arg2 } // …or inside it: let closure2 = { (arg1: Int, arg2: Int) -gt; Int in  return arg1 + arg2 } // In most cases, closure’s return type can be inferred automatically by the compiler. // However, this functionality may not work for too complex expressions. let closure3 = { arg1: Int, arg2: Int in  return arg1 + arg2 }

Swift имеет следующий синтаксис закрытия:

// This function takes a closure which receives no input parameters and returns an integer, // evaluates it, and uses the closure’s return value (an Int) as the function’s return value. func foo(closure bar: () -gt; Int) -gt; Int {  return bar() } // Without trailing closure syntax: foo(closure: { return 1 }) // With trailing closure syntax: foo { return 1 }

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

// This function passes the return of the first closure as the parameter of the second, // and returns the second closure’s result: func foo(bar: () -gt; Int, baz: (Int) -gt; Int) -gt; Int { return baz(bar()) } // With no trailing closures: foo(bar: { return 1 }, baz: { x in return x + 1 }) // With 1 trailing closure: a(bar: { return 1 }) { x in return x + 1 }) // With 2 trailing closures (note that only the first closure’s argument name is ommited): a { return 1 } baz: { x in return x + 1 }

Вот критерии синтаксиса завершающего закрытия:

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

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

В средах Cocoa и Cocoa Touch многие общие классы были частью библиотеки Foundation Kit. Сюда входила строковая библиотека NSString (с использованием Unicode, UTF-8 в Swift 5, измененная с UTF-16 ), классы коллекций NSArray и NSDictionary и другие. Objective-C предоставил различные биты синтаксического сахара, позволяющие создавать некоторые из этих объектов на лету внутри языка, но после создания объекты управлялись с помощью объектных вызовов. Например, в Objective-C для объединения двух NSStrings требуются вызовы методов, подобные этому:

NSString *str = @"hello,"; str = [str stringByAppendingString:@" world"];

В Swift многие из этих базовых типов были перенесены в ядро ​​языка, и ими можно управлять напрямую. Например, строки невидимо связаны с NSString (при импорте Foundation) и теперь могут быть объединены с +оператором, что позволяет значительно упростить синтаксис; предыдущий пример становится:

var str = "hello," str += " world"

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

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

Опции и цепочки

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

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

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

let myValue = anOptionalInstance!.someMethod()

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

let myValue = anOptionalInstance?.someMethod()

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

let aTenant = aBuilding.tenantList[5] let theirLease = aTenant.leaseDetails let leaseStart = theirLease?.startDate

сводится к:

let leaseStart = aBuilding.tenantList[5].leaseDetails?.startDate

?Синтаксис обходит пирамиду обреченности.

Swift 2 представил новое ключевое слово guard для случаев, когда код должен прекратить выполнение, если какое-либо условие не выполнено:

guard let leaseStart = aBuilding.TenantList[5]?.leaseDetails?.startDate else { //handle the error case where anything in the chain is nil //else scope must exit the current method or loop } //continue, knowing that leaseStart is not nil

Использование guardимеет три преимущества. Хотя синтаксис может действовать как ifоператор, его основное преимущество заключается в невозможности обнуления. Если в ifзаявлении требуется регистр, он guardпредполагает случай на основе предоставленного условия. Кроме того, поскольку не guardсодержит области видимости, за исключением elseзакрытия, leaseStartона представляется как развернутая необязательная опция для суперобласти защиты. Наконец, если guardпроверка оператора завершилась неудачно, Swift требует, elseчтобы оператор завершил текущий метод или цикл, гарантируя, что leaseStartникогда не будет доступа, когда nil. Это выполняется с помощью ключевых слов return, continue, breakили throw, или путем вызова функции возвращая Never(например fatalError()).

Objective-C был слабо типизирован и позволял вызывать любой метод для любого объекта в любое время. Если вызов метода завершился неудачно, во время выполнения был обработчик по умолчанию, который вернул nil. Это означало, что не нужно было разворачивать или тестировать, эквивалентное утверждение в Objective-C:

leaseStart = [[[aBuilding tenantList:5] leaseDetails] startDate]

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

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

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

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

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

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

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

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

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

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

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

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

protocol StringConvertible { func toString() -gt; String }

Теперь этот протокол можно добавить в String без доступа к источнику базового класса:

extension String: StringConvertible { func toString() -gt; String { self } }

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

var someSortOfPrintableObject: StringConvertible... print(someSortOfPrintableObject.toString())

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

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

func !=lt;T: Equatablegt;(lhs: T, rhs: T) -gt; Bool

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

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

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

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

В системах, отличных от Apple, 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) для управления памятью. Раньше Apple требовала ручного управления памятью в Objective-C, но представила ARC в 2011 году, чтобы упростить выделение и освобождение памяти. Одной из проблем с ARC является возможность создания цикла сильных ссылок, где объекты ссылаются друг на друга таким образом, что вы можете достичь объекта, с которого вы начали, следуя ссылкам (например, A ссылается на B, B ссылается на A). Это заставляет их просачиваться в память, поскольку они никогда не освобождаются. Swift предоставляет ключевые слова weakи unownedпредотвращает сильные ссылочные циклы. Обычно отношения родитель-потомок будут использовать сильную ссылку, в то время как дочерний-родитель будет использовать любую weakссылку, где родители и дети могут не быть связаны, или unownedгде у ребенка всегда есть родитель, но у родителя может не быть ребенка. Слабые ссылки должны быть необязательными переменными, поскольку они могут меняться и становиться nil.

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

Отладка и другие элементы

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

Apple утверждает, что Swift - это «язык программирования промышленного качества, столь же выразительный и приятный, как язык сценариев».

Представление

Многие из функций, представленных в Swift, имеют хорошо известные компромиссы с производительностью и безопасностью. Apple реализовала оптимизацию, уменьшающую эти накладные расходы.

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

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

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

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

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

Отличия от Objective-C:

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

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

Поскольку язык является открытым, есть перспективы его переноса в Интернет. Некоторые веб - структуры уже разработаны, такие как IBM «s Kitura, Совершенный и Vapor.

Официальная рабочая группа «Серверные API-интерфейсы» также была создана Apple, в которой члены сообщества разработчиков Swift играют центральную роль.

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

Комбинируя инструменты из LLVM и Macintosh Programmer's Workshop, можно запустить очень небольшое подмножество языка в Mac OS 9.

Смотрите также

использованная литература

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

Последняя правка сделана 2023-04-17 02:14:51
Содержание доступно по лицензии CC BY-SA 3.0 (если не указано иное).
Обратная связь: support@alphapedia.ru
Соглашение
О проекте