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

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

Быстрый

Логотип
Парадигма	Мультипарадигма : протокольно-ориентированная , объектно-ориентированная , функциональная , императивная , блочно-структурированная , декларативная , параллельная.
Разработано	Крис Лэттнер , Дуг Грегор, Джон Макколл, Тед Кременек, Джо Грофф и Apple Inc.
Разработчик	Apple Inc. и участники открытого исходного кода
Впервые появился	2 июня 2014 г ( 2014-06-02 )
Стабильная версия	5.10.1   / 5 июня 2024 г ( 5 июня 2024 г. )
Предварительный выпуск	6.0
Дисциплина набора текста	Статический , сильный , предполагаемый
Управление памятью	Автоматический подсчет ссылок
ТЫ	Операционные системы 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 , Д
Под влиянием
Ржавчина , В (Вланг)

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.

Официальные загрузки SDK и набора инструментов для дистрибутива 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 г.	Да	Да	Да
5.10.1	5 июня 2024 г.	Да	Да	Да

Функции

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

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

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

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

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

print("Hello, world!")

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

let highScoreThreshold = 1000 // A constant with type Int. The type was inferred based on the provided value.

var currentScore = 980 // A variable with type Int.
currentScore = 1200 // The value of variables can change over time.

let playerMessage: String // A constant with explicit type String.
if currentScore > highScoreThreshold {
    playerMessage = "You are a top player!"
} else {
    playerMessage = "Better luck next time."
}

print(playerMessage) // Prints "You are a top player!"

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

let someNumber = 42
if someNumber % 2 == 0 { // Use the remainder operator to find the remainder of someNumber divided by 2.
    print("\(someNumber) is even.")
} else {
   print("\(someNumber) is odd.")
}

// Prints "42 is even."

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

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

let greeting = constructGreeting(for: "Craig")

print(greeting) // Prints "Hello Craig!"

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

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

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

let mathOperation = multiplyByTwo

print(mathOperation(21)) // Prints "42"

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

func divide(numerator: Int?, byDenominator denominator: Int) -> Int? {
    guard denominator != 0 else {
        print("Can't divide by 0.")
        return nil
    }
    
    guard let numerator else {
        print("The provided numerator is nil.")
        return nil
    }
    
    return numerator / denominator
}

let result = divide(numerator: 3, byDenominator: 0)
print("Division result is: \(result)")

// Prints:
// "Can't divide by 0."
// "Division result is: nil."

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

let someNumber = 42

switch someNumber {
case ..<0: 
    print("\(someNumber) negative.")
case 0: 
    print("\(someNumber) is 0.")
case 1...9:
    print("\(someNumber) greater than 0, but less than 10.")
default: 
    print("\(someNumber) is greater than 9.")
}

// Prints "42 is greater than 9."

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

let names = ["Will", "Anna", "Bart"]
for name in names {
    print(name)
}
// Prints:
// Will
// Anna
// Bart

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

// Add together all the numbers from 1 to 5.
var i = 1
var result = 0

while i <= 5 { // The loop performs its body as long as i is less than or equal to 5.  
    result += i // Add i to the current result.
    i += 1 // Increment i by 1.
}

print(result) // Prints "15"

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

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

// Closure type, defined by its input and output values, can be specified outside the closure:
let closure1: (Int, Int) -> Int = { arg1, arg2 in
    return arg1 + arg2
}

// …or inside it:
let closure2 = { (arg1: Int, arg2: Int) -> Int in
    return arg1 + arg2
}

// In most cases, closure's return type can be inferred automatically by the compiler.
let closure3 = { arg1: Int, arg2: Int in
    return arg1 + arg2
}

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

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: () -> Int) -> Int {
    return bar()
}

// Without trailing closure syntax:
foo(closure: { return 1 })

// With trailing closure syntax, and implicit return:
foo { 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: () -> Int, baz: (Int) -> Int) -> Int {
    return baz(bar())
}

// With no trailing closures:
foo(bar: { return 1 }, baz: { x in return x + 1 })

// With 1 trailing closure:
foo(bar: { return 1 }) { x in return x + 1 }

// With 2 trailing closures (only the first closure's argument name is omitted):
foo { return 1 } baz: { x in return x + 1 }

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

let names = ["Josephine", "Steve", "Chris", "Barbara"]

// filter calls the given closure for each value in names. 
// Values with a character count less than 6 are kept, the others are dropped.
let shortNames = names.filter { $0.count < 6 }

print(shortNames) // Prints "["Steve", "Chris"]"

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

func makeMultiplier(withMultiple multiple: Int) -> (Int) -> (Int) {
    // Create and return a closure that takes in an Int and returns the input multiplied by the value of multiple.
    return {
        $0 * multiple
    }
}

let multiplier = makeMultiplier(withMultiple: 3)
print(multiplier(3)) // Prints "9"
print(multiplier(10)) // Prints "30"

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

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

var someString = "Hello,"
someString += " world!"

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

var currentScore = 980
print("Your score is \(currentScore).")

// Prints "Your score is 980."

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

for character 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 value: Int
    func callAsFunction(_ number: Int, scale: Int) {
        print(scale * (number + value))
    }
}
let callable = CallableStruct(value: 100)
callable(4, scale: 2)
callable.callAsFunction(4, scale: 2)
// Both function calls print 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 ценить.

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

let myValue = anOptionalInstance!.someMethod()

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

let myValue = anOptionalInstance?.someMethod()

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

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

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

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

Использование дополнительных опций в 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 {
        return height * width
    }
}

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

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

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

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

// Define a protocol named Printable
protocol Printable {
    var description: String { get } // A read-only property requirement
    func printDetails() // A method requirement
}

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

// Adopt the Printable protocol in a class
class MyClass: Printable {
    var description: String {
        return "An instance of MyClass"
    }

    func printDetails() {
        print(description)
    }
}

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

extension Printable { // All Printable instances will receive this implementation, or they may define their own.
    func printDetails() {
        print(description)
    }
}

// Bool now conforms to Printable, and inherits the printDetails() implementation above.
extension Bool: Printable {
    var description: String {
        return "An instance of Bool with value: \(self)"
    }

}

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

func getSomethingPrintable() -> any Printable {
    return true
}

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

// Prints "An instance of Bool with value: true"

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

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

func !=<T : Equatable>(lhs: T, rhs: T) -> Bool

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

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

extension Array where Element: Equatable {

    // allEqual will be available only on instances of Array that contain Equatable elements. 
    func allEqual() -> Bool {
        for element in self {
            if element != self.first {
                return false
            }
        }
        return true
    }
}

Параллелизм

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

func downloadText(name: String) async -> String {
    let result = // ... some asynchronous downloading code ...
    return result
}

let text = await downloadText("text1")

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

// Each of these calls to downloadText will run in parallel.
async let text1 = downloadText(name: "text1")
async let text2 = downloadText(name: "text2")
async let text3 = downloadText(name: "text3")

let textToPrint = await [text1, text2, text3] // Suspends until all three downloadText calls have returned.
print(textToPrint)

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

let taskHandle = Task {
    await downloadText(name: "someText")
}

let result = await taskHandle.value

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

actor Directory {
    var names: [String] = []
    
    func add(name: String) {
        names.append(name)
    }
}

let directory = Directory()

// Code suspends until other tasks finish accessing the actor.
await directory.add(name: "Tucker")
print(await directory.names)

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

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

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

class Person {
    let name: String
    weak var home: Home? // Defined as a weak reference in order to break the reference cycle. weak references do not increment the reference count of the instance that they refer to.
    
    init(name: String) {
        self.name = name
    }
    
    deinit { print("De-initialized \(name)") }
}

class Home {
    let address: String
    var owner: Person?
    
    init(address: String, owner: Person?) {
        self.address = address
        self.owner = owner
    }
    
    deinit { print("De-initialized \(address)") }
}

var stacy: Person? = Person(name: "Stacy")
var house21b: Home? = Home(address: "21b Baker Street", owner: stacy)

stacy?.home = house21b // stacy and house42b now refer to each other.

stacy = nil // The reference count for stacy is now 1, because house21b is still holding a reference to it. 
house21b = nil // house21b's reference count drops to 0, which in turn drops stacy's count to 0 because house21b was the last instance holding a strong reference to stacy.

// Prints:
// De-initialized 21b Baker Street
// De-initialized Stacy

Отладка

Ключевым элементом системы 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, ориентированная на Cocoa , Microsoft ( Common Language Infrastructure .NET Framework , теперь .NET ), а также на платформы Java и Android, существует как часть компилятора Elements от RemObjects Software .

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

См. также

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

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

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