Swift (programovací jazyk)

Swift
Druh	multiparadigmatický: protokolovo orientovaný, objektovo orientovaný, funkcionálny, imperatívny, blokovo štruktúrovaný, deklaratívny, súbežný
Dátum vzniku	2. jún 2014
Použitie	operačné systémy spoločnosti Apple (Darwin, iOS, iPadOS, macOS, tvOS, visionOS, watchOS), Linux, Windows, FreeBSD, Android, z/OS
Typová kontrola	statická, silná, odvodzovaná
Tvorca	Chris Lattner, Doug Gregor, John McCall, Ted Kremenek, Joe Groff a spoločnosť Apple
Implementácie	swiftc, Silver (Elements Compiler)
Používané prípony	.swift, .SWIFT

Swift je vysokoúrovňový všeobecný multiparadigmatický kompilovaný programovací jazyk, ktorý v roku 2010 vytvoril Chris Lattner pre spoločnosť Apple a ktorý udržiava komunita otvoreného softvéru. Swift sa kompiluje do strojového kódu a používa kompilátor založený na LLVM. Prvýkrát bol vydaný v júni 2014 a nástroje jazyka Swift sú súčasťou vývojového prostredia Xcode od verzie 6, vydanej v septembri 2014.

Apple chcel, aby Swift podporoval mnohé základné koncepty spojené s jazykom Objective-C, najmä dynamické viazanie metód (angl. dynamic dispatch), rozšírené neskoré viazanie, rozšíriteľné programovanie a podobné vlastnosti, no „bezpečnejším“ spôsobom, ktorý uľahčuje odhaľovanie softvérových chýb. Swift má prvky, ktoré predchádzajú niektorým bežným programátorským chybám, napríklad dereferencovaniu nulového ukazovateľa, a poskytuje syntaktický cukor, ktorý pomáha vyhnúť sa takzvanej pyramíde skazy (angl. pyramid of doom), teda hlboko vnoreným blokom kódu. Swift podporuje koncept rozšíriteľnosti pomocou protokolov – systém rozšírení, ktorý sa dá použiť na typy, štruktúry a triedy a ktorý Apple propaguje ako skutočnú zmenu programovacej paradigmy nazývanú „protokolovo orientované programovanie“ (podobné vlastnostiam (angl. traits) a typovým triedam).

Swift bol predstavený na vývojárskej konferencii Apple Worldwide Developers Conference (WWDC) v roku 2014. V roku 2014 prešiel aktualizáciou na verziu 1.2 a na konferencii WWDC 2015 zásadnou aktualizáciou na Swift 2. Pôvodne to bol proprietárny jazyk, no verzia 2.2 bola 3. decembra 2015 uvoľnená ako otvorený softvér pod licenciou Apache 2.0 pre platformy spoločnosti Apple a pre Linux.

História

S vývojom jazyka Swift začal v júli 2010 Chris Lattner, ku ktorému sa neskôr pridali mnohí ďalší programátori spoločnosti Apple. Podnetom bola potreba nahradiť starší programovací jazyk spoločnosti Apple Objective-C, ktorý sa od začiatku 80. rokov 20. storočia takmer nezmenil a chýbali mu moderné jazykové prvky. Swift prevzal myšlienky „z jazykov Objective-C, Rust, Haskell, Ruby, Python, C#, CLU a z mnohých ďalších, ktoré sa ani nedajú vymenovať“. Jazyk ovplyvnil aj D a Swift naopak ovplyvnil jazyky Rust, V (Vlang), Mojo a Carbon. Dňa 2. júna 2014 sa aplikácia konferencie WWDC stala prvou verejne vydanou aplikáciou napísanou v jazyku Swift. Registrovaným vývojárom platforiem Apple bola na konferencii sprístupnená beta verzia jazyka, spoločnosť však nesľúbila, že finálna verzia jazyka Swift bude na úrovni zdrojového kódu kompatibilná s testovacou verziou. Apple plánoval v prípade potreby sprístupniť pri plnom vydaní prevodníky zdrojového kódu.

Na konferencii WWDC bola vydaná aj bezplatná 500-stranová príručka The Swift Programming Language, dostupná v obchode Apple Books a na oficiálnej stránke.

Swift dosiahol míľnik 1.0 dňa 9. septembra 2014 spolu s verziou Gold Master vývojového prostredia Xcode 6.0 pre iOS. Swift 1.1 vyšiel 22. októbra 2014 spolu s Xcode 6.1. Swift 1.2 vyšiel 8. apríla 2015 spolu s Xcode 6.3. Swift 2.0 bol ohlásený na konferencii WWDC 2015 a 21. septembra 2015 bolo možné v ňom publikovať aplikácie v obchode App Store.

Swift 3.0 vyšiel 13. septembra 2016. Až po verziu 3.0 prechádzala syntax jazyka Swift výrazným vývojom; v neskorších verziách sa hlavný tím zameral na stabilitu zdrojového kódu.

Swift 4.0, vydaný 19. septembra 2017, priniesol viacero zmien v niektorých vstavaných triedach a štruktúrach. Kód napísaný v predchádzajúcich verziách jazyka Swift sa dá aktualizovať pomocou nástroja na migráciu zabudovaného v Xcode. Swift 4.1 vyšiel 29. marca 2018. V rebríčku popularity programovacích jazykov RedMonk z januára 2018 sa Swift vyrovnal jazyku Objective-C.

Swift 5, vydaný v marci 2019, zaviedol na platformách Apple stabilné binárne rozhranie, vďaka ktorému mohlo byť behové prostredie jazyka Swift začlenené do operačných systémov spoločnosti Apple. Je kompatibilný so zdrojovým kódom pre Swift 4.

Swift 5.1 bol oficiálne vydaný v septembri 2019. Nadväzuje na Swift 5 tým, že stabilitu rozšíril aj na čas kompilácie zavedením stability modulov. Stabilita modulov umožňuje vytvárať a zdieľať binárne knižnice (angl. frameworks), ktoré budú fungovať aj s budúcimi verziami jazyka Swift. Swift 5.5, ktorý Apple oficiálne ohlásil na konferencii WWDC 2021, výrazne rozširuje podporu súbežnosti a asynchrónneho kódu a zavádza najmä vlastnú verziu modelu aktorov. Swift 5.9 vyšiel v septembri 2023 a obsahuje systém makier, balíky generických parametrov (angl. generic parameter packs) a prvky vlastníctva (angl. ownership), ako je nový operátor consume. Swift 5.10, vydaný v marci 2024, vylepšuje model súbežnosti jazyka a umožňuje úplnú izoláciu údajov, ktorá zabraňuje súbehu pri prístupe k údajom (angl. data race).

Swift 6 vyšiel v septembri 2024. Swift 6.1 vyšiel v marci 2025. Obsahuje „nové jazykové vylepšenia na zvýšenie produktivity, vylepšenia diagnostiky, vlastnosti balíkov (angl. package traits) a pokračujúcu prácu na zlepšení použiteľnosti bezpečnosti pred súbehom pri prístupe k údajom a času kompilácie“. Swift 6.4 vyšiel 15. septembra 2026; k 31. októbru 2026 je najnovšou verziou 6.4.2.

V prieskume vývojárov Stack Overflow Developer Survey získal Swift v roku 2015 prvé miesto v kategórii Most Loved Programming Language (najobľúbenejší programovací jazyk) a v roku 2016 druhé miesto.

Dňa 3. decembra 2015 boli jazyk Swift, podporné knižnice, ladiaci program a správca balíkov uvoľnené ako otvorený softvér pod licenciou Apache 2.0 s výnimkou pre behovú knižnicu (angl. Runtime Library Exception) a na hosťovanie projektu vznikla stránka Swift.org. Zdrojový kód je uložený na platforme GitHub, kde si ho ktokoľvek môže ľahko stiahnuť, sám zostaviť a dokonca prostredníctvom žiadostí o začlenenie (angl. pull requests) prispievať kódom späť do projektu.

V decembri 2015 spoločnosť IBM ohlásila webovú stránku Swift Sandbox, na ktorej mohli vývojári písať kód v jazyku Swift v jednom paneli a výstup zobraziť v druhom. Swift Sandbox bol v januári 2018 ukončený.

Počas konferencie WWDC 2016 Apple ohlásil aplikáciu Swift Playgrounds, určenú výlučne pre iPad, ktorá má ľudí naučiť programovať v jazyku Swift. Aplikácia má rozhranie pripomínajúce trojrozmernú videohru, ktoré poskytuje spätnú väzbu, keď sú riadky kódu usporiadané v určitom poradí a spustené.

V januári 2017 Chris Lattner oznámil, že odchádza zo spoločnosti Apple na novú pozíciu v spoločnosti Tesla Motors; vedenie projektu Swift prevzal dlhoročný člen tímu Ted Kremenek.

Počas konferencie WWDC 2019 Apple spolu s Xcode 11 ohlásil SwiftUI, rámec na deklaratívny návrh štruktúry používateľského rozhrania na všetkých platformách spoločnosti Apple.

Oficiálne balíky SDK a súboru nástrojov (angl. toolchain) pre distribúciu Ubuntu systému Linux sú k dispozícii od verzie Swift 2.2; od verzie Swift 5.2.4 pribudli ďalšie distribúcie, CentOS a Amazon Linux. Pre systém Android existuje neoficiálne SDK a balík natívnych nástrojov a v októbri 2025 pracovná skupina jazyka Swift pre Android ohlásila predbežnú verziu oficiálneho SDK jazyka Swift pre Android.

Platformy

Swift podporuje operačné systémy spoločnosti Apple (Darwin, iOS, iPadOS, macOS, tvOS, watchOS), Linux, Windows, WebAssembly a Android.

Kľúčovou vlastnosťou návrhu jazyka Swift je schopnosť spolupracovať s obrovským množstvom existujúceho kódu v jazyku Objective-C, ktorý bol pre produkty Apple vyvinutý počas predchádzajúcich desaťročí, napríklad s rámcami Cocoa a Cocoa Touch. Na platformách Apple sa Swift spája s behovou knižnicou jazyka Objective-C, vďaka čomu môže v jednom programe bežať kód v jazykoch C, Objective-C, C++ a Swift.

História verzií

Tabuľka uvádza hlavné a vedľajšie verzie (opravné verzie typu 5.6.1 sú vynechané).

Verzia jazyka Swift	Dátum vydania	macOS	Linux	Windows
1.0	9. septembra 2014	áno	nie	nie
1.1	22. októbra 2014	áno	nie	nie
1.2	8. apríla 2015	áno	nie	nie
2.0	21. septembra 2015	áno	nie	nie
2.1	20. októbra 2015	áno	nie	nie
2.2	21. marca 2016	áno	áno	nie
3.0	13. septembra 2016	áno	áno	nie
3.1	27. marca 2017	áno	áno	nie
4.0	19. septembra 2017	áno	áno	nie
4.1	29. marca 2018	áno	áno	nie
4.2	17. septembra 2018	áno	áno	nie
5.0	25. marca 2019	áno	áno	nie
5.1	10. septembra 2019	áno	áno	nie
5.2	24. marca 2020	áno	áno	nie
5.3	16. septembra 2020	áno	áno	áno
5.4	26. apríla 2021	áno	áno	áno
5.5	20. septembra 2021	áno	áno	áno
5.6	14. marca 2022	áno	áno	áno
5.7	12. septembra 2022	áno	áno	áno
5.8	30. marca 2023	áno	áno	áno
5.9	18. septembra 2023	áno	áno	áno
5.10	5. marca 2024	áno	áno	áno
6.0	16. septembra 2024	áno	áno	áno
6.1	31. marca 2025	áno	áno	áno
6.2	17. septembra 2025	áno	áno	áno
6.3	27. marca 2026	áno	áno	áno
6.4	15. septembra 2026	áno	áno	áno

Vlastnosti

Swift je všeobecný programovací jazyk, ktorý využíva moderné koncepty teórie programovacích jazykov a snaží sa ponúknuť jednoduchú, no zároveň výkonnú syntax. Spája inovácie a konvencie rôznych programovacích jazykov, s výraznou inšpiráciou jazykom Objective-C, ktorý nahradil ako hlavný vývojový jazyk na platformách spoločnosti Apple.

Swift bol navrhnutý tak, aby bol bezpečný a prívetivý k začínajúcim programátorom bez toho, aby obetoval rýchlosť. Swift predvolene spravuje všetku pamäť automaticky a zabezpečuje, aby boli premenné pred použitím vždy inicializované. Pri prístupe k poliam sa kontroluje prekročenie hraníc a pri celočíselných operáciách pretečenie. Názvy parametrov umožňujú vytvárať zrozumiteľné rozhrania API. Protokoly definujú rozhrania, ktoré môžu typy prijať, a rozšírenia umožňujú vývojárom pridávať existujúcim typom ďalšie funkcie. Swift umožňuje objektovo orientované programovanie s podporou tried, podtypov a prekrývania metód. Voliteľné typy (angl. optionals) umožňujú explicitne a bezpečne pracovať s hodnotami nil. Súbežné programy sa dajú písať pomocou syntaxe async/await a aktory izolujú zdieľaný meniteľný stav, aby sa zabránilo súbehu pri prístupe k údajom.

Základná syntax

Syntax jazyka Swift je podobná jazykom v štýle jazyka C. Kód sa predvolene začína vykonávať v globálnom rozsahu platnosti. Alternatívne možno atribút @main použiť na deklaráciu štruktúry, triedy alebo enumerácie, čím sa označí, že obsahuje vstupný bod programu.

Program „Hello, World!“ v jazyku Swift vyzerá takto:

print("Hello, world!")

Použitá funkcia print(_:separator:terminator:) je súčasťou štandardnej knižnice jazyka Swift, ktorá je dostupná všetkým programom bez potreby importovať externé moduly. Príkazy v jazyku Swift nemusia končiť bodkočiarkou, bodkočiarky sú však povinné na oddelenie viacerých príkazov napísaných na tom istom riadku. Jednoriadkové komentáre sa začínajú znakmi // a pokračujú do konca riadku. Viacriadkové komentáre sú uzavreté medzi znaky /* a */. Konštanty (premenné, ktoré nemožno meniť) sa deklarujú kľúčovým slovom let, kým premenné deklarované kľúčovým slovom var sa meniť môžu. Hodnoty musia byť pred čítaním inicializované. Typ premennej môže byť odvodený z typu zadanej počiatočnej hodnoty. Ak sa počiatočná hodnota nastaví až po deklarácii, typ treba deklarovať explicitne.

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!"

Riadenie toku programu v jazyku Swift zabezpečujú príkazy if-else, guard a switch spolu s cyklami while a for-in. Príkazy if prijímajú booleovský parameter a ak je podmienka pravdivá, vykonajú telo príkazu if, inak vykonajú voliteľné telo else. Syntax if-let poskytuje syntaktický cukor na overenie existencie voliteľnej hodnoty a jej súčasné rozbalenie.

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."

Funkcie sa definujú kľúčovým slovom func. Parametre funkcií môžu mať názvy, vďaka ktorým sa volania funkcií čítajú ako vety. Podčiarkovník pred názvom parametra umožňuje vynechať označenie argumentu v mieste volania. Funkcie môžu pomocou n-tíc vrátiť naraz viac údajov.

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

let greeting = constructGreeting(for: "Craig")

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

Funkcie a anonymné funkcie nazývané uzávery (angl. closures) možno priraďovať vlastnostiam a odovzdávať v programe ako akúkoľvek inú hodnotu.

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

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

let mathOperation = multiplyByTwo

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

Príkazy guard vyžadujú, aby bola daná podmienka pred pokračovaním za príkazom guard pravdivá, inak sa vykoná telo uvedenej klauzuly else. Klauzula else musí opustiť blok kódu, v ktorom sa príkaz guard nachádza. Príkazy guard sú užitočné na overenie, že sú splnené určité požiadavky, skôr ako program pokračuje vo vykonávaní. Dajú sa nimi najmä vytvoriť rozbalené verzie voliteľných hodnôt, ktoré sú zaručene rôzne od nil po zvyšok obklopujúceho rozsahu platnosti.

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."

Príkazy switch porovnávajú hodnotu s viacerými možnými hodnotami a vykonajú priradený blok kódu. Príkazy switch musia byť úplné, buď tak, že obsahujú vetvy pre všetky možné hodnoty, alebo vetvu default, ktorá sa vykoná, keď zadaná hodnota nezodpovedá žiadnej inej vetve. Vetvy switch implicitne nepokračujú do nasledujúcej vetvy, hoci tak môžu urobiť explicitne pomocou kľúčového slova fallthrough. V príkazoch switch sa dá rôznymi spôsobmi použiť porovnávanie vzorov (angl. pattern matching). Tu je príklad celého čísla porovnávaného s niekoľkými možnými rozsahmi:

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."

Cykly for-in prechádzajú postupnosťou hodnôt:

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

Cykly while sa opakujú, kým sa daná booleovská podmienka vyhodnocuje ako 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"

Podpora uzáverov

Swift podporuje uzávery (angl. closures), čo sú samostatné bloky funkcionality, ktoré možno odovzdávať a používať v kóde a ktoré možno použiť aj ako anonymné funkcie. Tu je niekoľko príkladov:

// 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
}

Uzávery možno priraďovať premenným a konštantám a odovzdávať ich ako parametre iným funkciám alebo uzáverom. Uzávery s jediným výrazom môžu vynechať kľúčové slovo return.

Swift má aj syntax koncového uzáveru (angl. trailing closure), ktorá umožňuje zapísať uzáver za koniec volania funkcie namiesto do zoznamu jej parametrov. Ak je uzáver jediným parametrom funkcie, zátvorky možno úplne vynechať:

// 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 }

Od verzie 5.3 Swift podporuje viacero koncových uzáverov:

// 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 poskytuje pre vložené uzávery skrátené názvy argumentov, takže nie je potrebné explicitne pomenovať všetky parametre uzáveru. Na argumenty sa možno odvolávať názvami $0, $1, $2 atď.:

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"]"

Uzávery môžu zachytávať hodnoty z okolitého rozsahu platnosti. Uzáver sa na zachytenú hodnotu odvoláva po celý čas svojej existencie:

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"

Podpora reťazcov

Štandardná knižnica jazyka Swift obsahuje typy String a Character vyhovujúce štandardu Unicode. Hodnoty typu String možno inicializovať reťazcovým literálom, teda postupnosťou znakov uzavretou v dvojitých úvodzovkách. Reťazce možno spájať operátorom +:

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

Interpolácia reťazcov umožňuje vytvoriť nový reťazec z iných hodnôt a výrazov. Hodnoty zapísané v zátvorkách, pred ktorými je znak \, sa vložia do obklopujúceho reťazcového literálu:

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

// Prints "Your score is 980."

Cyklom for-in možno prechádzať znakmi obsiahnutými v reťazci:

for character in "Swift" {
    print(character)
}
// S
// w
// i
// f
// t

Ak je importovaný rámec Foundation, Swift typ String nenápadne premosťuje na NSString (triedu reťazca bežne používanú v jazyku Objective-C).

Volateľné objekty

V jazyku Swift sa volateľné objekty definujú pomocou metódy 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.

Riadenie prístupu

Swift podporuje päť úrovní riadenia prístupu k symbolom: open, public, internal, fileprivate a private. Na rozdiel od mnohých objektovo orientovaných jazykov tieto úrovne ignorujú hierarchie dedičnosti: private znamená, že symbol je prístupný len v bezprostrednom rozsahu platnosti, fileprivate, že je prístupný len v rámci súboru, internal, že je prístupný v rámci obsahujúceho modulu, public, že je prístupný z ľubovoľného modulu, a open (len pre triedy a ich metódy), že od triedy možno odvodzovať podtriedy aj mimo modulu.

Voliteľné typy a reťazenie

Dôležitou vlastnosťou jazyka Swift sú voliteľné typy (angl. option types), ktoré umožňujú, aby sa referencie alebo hodnoty správali podobne ako bežný vzor v jazyku C, kde ukazovateľ môže odkazovať buď na konkrétnu hodnotu, alebo na žiadnu hodnotu. To znamená, že nevoliteľné typy nemôžu viesť k chybe nulového ukazovateľa; kompilátor dokáže zabezpečiť, že to nie je možné.

Voliteľné typy sa vytvárajú pomocou enumerácie Optional. Ak chceme vytvoriť celé číslo, ktoré môže mať hodnotu nil, použijeme deklaráciu podobnú var optionalInteger: Optional<Int>. Podobne ako jazyk C# obsahuje aj Swift na tento účel syntaktický cukor, ktorý umožňuje označiť premennú ako voliteľnú otáznikom za názvom typu: var optionalInteger: Int?. Premenné alebo konštanty označené ako voliteľné majú buď hodnotu základného typu, alebo hodnotu nil. Voliteľné typy obaľujú základný typ, čím vzniká iná inštancia. String a String? sú zásadne odlišné typy: prvý je typu String, kým druhý je typu Optional, ktorý môže obsahovať nejakú hodnotu typu String.

Ak chceme pristúpiť k vnútornej hodnote (za predpokladu, že nie je nil), treba ju rozbaliť, aby sa sprístupnila vnútorná inštancia. Robí sa to operátorom !:

let myValue = anOptionalInstance!.someMethod()

V tomto prípade operátor ! rozbalí anOptionalInstance a sprístupní vnútornú inštanciu, takže na nej možno zavolať metódu. Ak je anOptionalInstance nil, nastane chyba nulového ukazovateľa, ktorá ukončí program. Tento postup sa nazýva vynútené rozbalenie (angl. force unwrapping). Voliteľné hodnoty možno bezpečne rozbaliť pomocou voliteľného reťazenia (angl. optional chaining), ktoré najprv overí, či je inštancia nil, a ak nie je, rozbalí ju:

let myValue = anOptionalInstance?.someMethod()

V tomto prípade behové prostredie zavolá someMethod len vtedy, ak anOptionalInstance nie je nil, čím sa chyba potlačí. Za každou voliteľnou vlastnosťou musí byť znak ?. Ak je ktorákoľvek z týchto vlastností nil, celý výraz sa vyhodnotí ako nil. Pôvod termínu reťazenie pochádza z častejšieho prípadu, keď je za sebou zreťazených niekoľko volaní metód alebo getterov. Napríklad:

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

možno skrátiť na:

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

Používanie voliteľných typov v jazyku Swift umožňuje kompilátoru použiť statické viazanie (angl. static dispatch), pretože akcia rozbalenia sa volá na definovanej inštancii (obale), a nie v systéme viazania počas behu programu.

Hodnotové typy

V mnohých objektovo orientovaných jazykoch sú objekty interne reprezentované dvoma časťami. Objekt je uložený ako blok údajov na halde, kým názov (alebo „rukoväť“) tohto objektu je reprezentovaný ukazovateľom. Objekty sa medzi metódami odovzdávajú kopírovaním hodnoty ukazovateľa, takže k tým istým údajom na halde môže pristupovať ktokoľvek, kto má kópiu. Naproti tomu základné typy, ako sú celé čísla a hodnoty s pohyblivou rádovou čiarkou, sú reprezentované priamo; rukoväť obsahuje samotné údaje, nie ukazovateľ na ne, a tieto údaje sa metódam odovzdávajú priamo kopírovaním. Tieto spôsoby prístupu sa nazývajú odovzdávanie odkazom (angl. pass-by-reference) v prípade objektov a odovzdávanie hodnotou (angl. pass-by-value) v prípade základných typov.

Oba koncepty majú svoje výhody aj nevýhody. Objekty sú užitočné, keď sú údaje veľké, napríklad opis okna alebo obsah dokumentu. V takých prípadoch sa prístup k údajom zabezpečuje kopírovaním 32- alebo 64-bitovej hodnoty namiesto kopírovania celej údajovej štruktúry. Menšie hodnoty, ako sú celé čísla, však majú rovnakú veľkosť ako ukazovatele (zvyčajne oboje jedno slovo), takže odovzdávanie ukazovateľa namiesto hodnoty neprináša žiadnu výhodu.

Swift ponúka vstavanú podporu objektov so sémantikou odovzdávania odkazom aj hodnotou: prvá sa používa pri deklarácii class, druhá pri deklarácii struct. Štruktúry majú v jazyku Swift takmer všetky vlastnosti tried: metódy, implementáciu protokolov a využívanie mechanizmu rozšírení. Preto Apple všetky údaje všeobecne nazýva inštancie, a nie objekty alebo hodnoty. Štruktúry však nepodporujú dedičnosť.

Programátor si môže pre každú údajovú štruktúru v aplikácii zvoliť vhodnejšiu sémantiku. Väčšie štruktúry, napríklad okná, sa definujú ako triedy, aby sa dali odovzdávať ako ukazovatele. Menšie štruktúry, napríklad dvojrozmerný bod, sa dajú definovať ako štruktúry, ktoré sa odovzdávajú hodnotou a umožňujú priamy prístup k svojim vnútorným údajom bez nepriameho adresovania či počítania referencií. Zlepšenie výkonu spojené s odovzdávaním hodnotou je také, že Swift tieto typy používa takmer pre všetky bežné údajové typy vrátane Int a Double, ako aj pre typy bežne reprezentované objektmi, napríklad String a Array. Používanie hodnotových typov môže výrazne zlepšiť výkon aj v používateľských aplikáciách.

Typy Array, Dictionary a Set využívajú techniku kopírovania pri zápise (angl. copy on write), takže ich údaje sa skopírujú až vtedy, keď sa program pokúsi zmeniť v nich hodnotu. To znamená, že jednotlivé prístupové premenné majú v skutočnosti ukazovateľ na to isté úložisko údajov. Hoci sú teda údaje fyzicky uložené v pamäti ako jedna inštancia, na úrovni aplikácie sú tieto hodnoty oddelené a fyzické oddelenie sa pomocou kopírovania pri zápise vynúti len v prípade potreby.

Rozšírenia

Rozšírenia (angl. extensions) pridávajú existujúcemu typu novú funkcionalitu bez potreby odvodzovať podtriedu alebo mať prístup k pôvodnému zdrojovému kódu. Rozšírenia môžu pridávať nové metódy, inicializátory, vypočítavané vlastnosti, indexery (angl. subscripts) a zhodu s protokolmi. Príkladom môže byť pridanie kontroly pravopisu do základného typu String, vďaka čomu všetky inštancie typu String v programe získajú schopnosť kontrolovať pravopis. Systém sa široko používa aj ako organizačná technika, ktorá umožňuje zhromaždiť súvisiaci kód do rozšírení podobných knižniciam.

Rozšírenia sa deklarujú kľúčovým slovom extension.

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

extension Rectangle {
    var area: Double {
        return height * width
    }
}

Protokolovo orientované programovanie

Protokoly zaručujú, že určitý typ implementuje množinu metód alebo vlastností, takže ostatné inštancie v systéme môžu tieto metódy volať na ľubovoľnej inštancii, ktorá daný protokol implementuje. V moderných objektovo orientovaných jazykoch sa to často používa ako náhrada viacnásobnej dedičnosti, hoci súbory vlastností nie sú úplne rovnaké.

V jazyku Objective-C a vo väčšine ďalších jazykov, ktoré implementujú koncept protokolov, je na programátorovi, aby zabezpečil, že požadované metódy budú implementované v každej triede. Swift pridáva možnosť doplniť tieto metódy pomocou rozšírení a implementovať ich pomocou generického programovania. Spolu to umožňuje napísať protokoly raz a podporovať nimi širokú škálu inštancií. Mechanizmus rozšírení možno použiť aj na pridanie zhody s protokolom objektu, ktorý tento protokol vo svojej definícii neuvádza.

Napríklad možno deklarovať protokol s názvom Printable, ktorý zaručuje, že inštancie vyhovujúce protokolu implementujú vlastnosť description a požadovanú metódu printDetails():

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

Tento protokol teraz môžu prijať iné typy:

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

    func printDetails() {
        print(description)
    }
}

Rozšírenia možno použiť na pridanie zhody s protokolom k typom. Aj samotné protokoly možno rozširovať, aby poskytovali predvolené implementácie svojich požiadaviek. Typy, ktoré protokol prijmú, môžu definovať vlastné implementácie alebo použiť predvolenú implementáciu:

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)"
    }

}

V jazyku Swift, podobne ako v mnohých moderných jazykoch podporujúcich rozhrania, možno protokoly používať ako typy, čo znamená, že premenné a metódy možno definovať pomocou protokolu namiesto konkrétneho typu:

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

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

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

Nezáleží na tom, akého konkrétneho typu je someSortOfPrintableInstance, kompilátor zabezpečí, že vyhovuje protokolu, a preto je tento kód bezpečný. Táto syntax tiež znamená, že aj kolekcie môžu byť založené na protokoloch, napríklad let printableArray = [any Printable].

Rozšírenia aj protokoly sa v štandardnej knižnici jazyka Swift používajú vo veľkej miere; vo verzii Swift 5.9 boli približne 1,2 percenta všetkých symbolov štandardnej knižnice protokoly a ďalších 12,3 percenta tvorili požiadavky protokolov alebo predvolené implementácie. Swift napríklad pomocou rozšírení pridáva protokol Equatable mnohým svojim základným typom, ako sú reťazce a polia, čo umožňuje porovnávať ich operátorom ==. Protokol Equatable definuje aj túto predvolenú implementáciu:

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

Táto funkcia definuje metódu, ktorá funguje na ľubovoľnej inštancii vyhovujúcej protokolu Equatable a poskytuje operátor nerovná sa. Každá inštancia, trieda či štruktúra, získa túto implementáciu automaticky len tým, že vyhovuje protokolu Equatable.

Kombináciou protokolov, rozšírení a generických typov možno vytvárať prepracované rozhrania API. Obmedzenia napríklad umožňujú typom podmienene prijímať protokoly alebo metódy v závislosti od vlastností prijímajúceho typu. Bežným prípadom použitia je pridanie metódy kolekciám len vtedy, keď prvky obsiahnuté v kolekcii vyhovujú protokolu 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
    }
}

Súbežnosť

Swift 5.5 zaviedol do jazyka štruktúrovanú súbežnosť (angl. structured concurrency). Štruktúrovaná súbežnosť používa syntax async/await podobnú jazykom Kotlin, JavaScript a Rust. Asynchrónna funkcia sa definuje kľúčovým slovom async za zoznamom parametrov. Pri volaní asynchrónnej funkcie treba pred funkciu napísať kľúčové slovo await, ktoré naznačuje, že vykonávanie volajúcej funkcie sa môže pozastaviť. Kým je funkcia pozastavená, program môže vykonávať inú súbežnú funkciu toho istého programu. Táto syntax umožňuje programom zreteľne označiť možné body pozastavenia a vyhnúť sa istej podobe pyramídy skazy, ktorú spôsobovalo predtým rozšírené používanie spätných volaní pomocou uzáverov.

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

let text = await downloadText("text1")

Syntax async let umožňuje spustiť viacero funkcií paralelne. Kľúčové slovo await sa opäť používa na označenie bodu, v ktorom sa program pozastaví a čaká na dokončenie skôr volaných funkcií 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)

Úlohy (angl. Tasks) a skupiny úloh (angl. TaskGroups) možno vytvárať aj explicitne, a tak počas behu programu vytvoriť dynamický počet podriadených úloh:

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

let result = await taskHandle.value

Swift používa model aktorov na izoláciu meniteľného stavu, čo umožňuje rôznym úlohám bezpečne meniť zdieľaný stav. Aktory sa deklarujú kľúčovým slovom actor a podobne ako triedy sú referenčnými typmi. K meniteľnému stavu aktora môže v danom okamihu pristupovať len jedna úloha. Aktory môžu voľne pristupovať k vlastnému vnútornému stavu a meniť ho, kód bežiaci v samostatných úlohách však musí každý prístup označiť kľúčovým slovom await, čím naznačuje, že kód sa môže pozastaviť, kým ostatné úlohy nedokončia prístup k stavu aktora.

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)

Knižnice, behové prostredie, vývoj

V systémoch Apple Swift používa to isté behové prostredie ako existujúci systém Objective-C, vyžaduje však iOS 7 alebo macOS 10.9 či novší. Závisí aj od knižnice Grand Central Dispatch. Kód v jazykoch Swift a Objective-C možno použiť v jednom programe a v dôsledku toho aj kód v jazykoch C a C++. Od verzie Swift 5.9 možno kód v jazyku C++ používať priamo z kódu v jazyku Swift. V prípade jazyka Objective-C má Swift rozsiahly prístup k objektovému modelu a možno ho použiť na odvodzovanie podtried, rozširovanie a používanie kódu v jazyku Objective-C na podporu protokolov. Opačne to neplatí: od triedy v jazyku Swift nemožno v jazyku Objective-C odvodiť podtriedu.

Na uľahčenie vývoja takýchto programov a opätovného použitia existujúceho kódu ponúka Xcode 6 a novšie poloautomatický systém, ktorý vytvára a udržiava takzvaný premosťujúci hlavičkový súbor (angl. bridging header), ktorý sprístupňuje kód v jazyku Objective-C jazyku Swift. Ide o ďalší hlavičkový súbor, ktorý jednoducho definuje alebo importuje všetky symboly jazyka Objective-C, ktoré kód projektu v jazyku Swift potrebuje. Swift sa potom môže odvolávať na typy, funkcie a premenné deklarované v týchto importoch, akoby boli napísané v jazyku Swift. Aj kód v jazyku Objective-C môže priamo používať kód v jazyku Swift, a to importovaním automaticky udržiavaného hlavičkového súboru s deklaráciami symbolov projektu v jazyku Objective-C. Napríklad súbor v jazyku Objective-C v zmiešanom projekte s názvom „MyApp“ môže pristupovať k triedam alebo funkciám jazyka Swift kódom #import "MyApp-Swift.h". Prostredníctvom tohto mechanizmu však nie sú dostupné všetky symboly – použitie prvkov špecifických pre Swift, ako sú generické typy, neobjektové voliteľné typy, prepracované enumerácie či dokonca identifikátory v Unicode, môže spôsobiť, že symbol nebude z jazyka Objective-C dostupný.

Swift má aj obmedzenú podporu atribútov – metaúdajov, ktoré číta vývojové prostredie a ktoré nemusia byť súčasťou skompilovaného kódu. Podobne ako v jazyku Objective-C atribúty používajú syntax @, súčasná dostupná sada je však malá. Jedným z príkladov je atribút @IBOutlet, ktorý označuje danú hodnotu v kóde ako outlet dostupný na použitie v nástroji Interface Builder (IB). Outlet je prostriedok, ktorý spája hodnotu zobrazenú na obrazovke s objektom v kóde.

V systémoch iných ako Apple Swift nezávisí od behového prostredia jazyka Objective-C ani od iných systémových knižníc spoločnosti Apple; nahrádza ich súbor implementácií „Corelib“ jazyka Swift. Patria medzi ne „swift-corelibs-foundation“ ako náhrada rámca Foundation Kit, „swift-corelibs-libdispatch“ ako náhrada knižnice Grand Central Dispatch a „swift-corelibs-xctest“ ako náhrada rozhraní XCTest z vývojového prostredia Xcode.

V roku 2019 Apple spolu s Xcode 11 pridal aj novú zásadnú paradigmu tvorby používateľského rozhrania nazvanú SwiftUI. SwiftUI nahrádza staršiu paradigmu nástroja Interface Builder novou deklaratívnou paradigmou vývoja.

Správa pamäte

Swift na správu pamäte používa automatické počítanie referencií (angl. Automatic Reference Counting, ARC). Každá inštancia triedy alebo uzáveru si udržiava počítadlo referencií, ktoré priebežne zaznamenáva počet referencií, ktoré program na ňu drží. Keď toto počítadlo klesne na 0, inštancia sa uvoľní. Toto automatické uvoľňovanie odstraňuje potrebu zberača odpadu, pretože inštancie sa uvoľňujú hneď, ako už nie sú potrebné.

Cyklus silných referencií (angl. strong reference cycle) môže vzniknúť, ak sa dve inštancie navzájom silno odkazujú (napr. A odkazuje na B a B odkazuje na A). Keďže počítadlo referencií ani jednej z inštancií nemôže nikdy klesnúť na nulu, ani jedna sa neuvoľní, čo vedie k úniku pamäte. Swift poskytuje kľúčové slová weak a unowned, ktoré cyklom silných referencií zabraňujú. Tieto kľúčové slová umožňujú odkazovať na inštanciu bez zvýšenia jej počítadla referencií. Referencie weak musia byť voliteľné premenné, pretože sa môžu zmeniť a nadobudnúť hodnotu nil. Pokus o prístup k hodnote unowned, ktorá už bola uvoľnená, vedie k chybe počas behu programu.

Cyklus silných referencií môže vytvoriť aj uzáver v rámci triedy, ak zachytí referencie na self. Referencie na self, s ktorými sa má zaobchádzať ako so slabými alebo nevlastniacimi, možno označiť pomocou zoznamu zachytenia (angl. capture list).

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

Ladenie

Kľúčovou súčasťou systému jazyka Swift je možnosť prehľadne ladiť a spúšťať kód vo vývojovom prostredí pomocou interaktívnej slučky čítania, vyhodnotenia a výpisu (angl. read–eval–print loop, REPL), vďaka čomu má Swift interaktívne vlastnosti, ktoré majú viac spoločného so skriptovacími možnosťami jazyka Python než s tradičnými systémovými programovacími jazykmi. REPL ďalej rozširujú takzvané ihriská (angl. playgrounds) – interaktívne zobrazenia bežiace v prostredí Xcode alebo v aplikácii Playgrounds, ktoré priebežne reagujú na zmeny v kóde alebo v ladiacom programe. Ihriská umožňujú programátorom pridávať kód v jazyku Swift spolu s dokumentáciou vo formáte Markdown. Programátori môžu krokovať kód a pridávať body prerušenia pomocou ladiaceho programu LLDB, a to buď v konzole, alebo vo vývojovom prostredí, ako je Xcode.

Porovnanie s inými jazykmi

Swift sa považuje za programovací jazyk z rodiny jazyka C a v mnohých ohľadoch sa jazyku C podobá:

• Väčšina operátorov jazyka C sa vyskytuje aj v jazyku Swift, hoci niektoré operátory, napríklad +, sa správajú trochu inak. Napríklad v jazyku Swift operátor + pri pretečení vyvolá chybu, kým &+ označuje správanie podobné jazyku C, teda pretočenie hodnoty pri pretečení.
• Na zoskupovanie príkazov sa používajú zložené zátvorky.
• Premenným sa hodnoty priraďujú znakom rovnosti, porovnávajú sa však dvoma znakmi rovnosti za sebou. Nový operátor identity === slúži na overenie, či dva údajové prvky odkazujú na ten istý objekt.
• Riadiace príkazy while, if a switch sú podobné, ale majú rozšírené funkcie, napríklad switch prijíma aj neceločíselné vetvy, while a if podporujú porovnávanie vzorov a podmienené rozbaľovanie voliteľných hodnôt a for používa syntax for i in 1...10.
• Hranaté zátvorky sa používajú pri poliach, a to na ich deklaráciu aj na získanie hodnoty na danom indexe.

Podobá sa aj na jazyk Objective-C:

• základné číselné typy: Int, UInt, Float, Double
• metódy triedy sa dedia rovnako ako metódy inštancie; self v metódach triedy je trieda, na ktorej bola metóda zavolaná
• podobná syntax enumerácie for...in

Rozdiely oproti jazyku Objective-C:

• Príkazy nemusia končiť bodkočiarkou (;), tá sa však musí použiť, ak je na jednom riadku viac príkazov.
• Žiadne hlavičkové súbory.
• Používa odvodzovanie typov (angl. type inference).
• Generické programovanie.
• Funkcie sú plnohodnotné objekty (angl. first-class).
• Vetvy enumerácie môžu mať priradené údaje (algebraické dátové typy).
• Operátory možno pre triedy predefinovať (preťažovanie operátorov) a možno definovať nové operátory.
• Reťazce plne podporujú Unicode. Väčšinu znakov Unicode možno použiť v identifikátoroch aj v operátoroch.
• Žiadne spracovanie výnimiek. Swift 2 zavádza iný, nekompatibilný model spracovania chýb.
• Viaceré prvky starších jazykov z rodiny jazyka C, ktoré sa dajú ľahko zneužiť, boli odstránené:
  • Ukazovatele nie sú predvolene sprístupnené. Programátor nemusí sledovať a označovať názvy na odkazovanie či dereferencovanie.
  • Priradenia nevracajú hodnotu. Tým sa predchádza bežnej chybe, keď sa namiesto i == 0 napíše i = 0 (čo vyvolá chybu počas kompilácie).
  • V blokoch switch netreba používať príkazy break. Jednotlivé vetvy nepokračujú do nasledujúcej vetvy, pokiaľ sa nepoužije príkaz fallthrough.
  • Premenné a konštanty sú vždy inicializované a hranice polí sa vždy kontrolujú.
  • Pretečenia celých čísel (angl. integer overflow), ktoré v jazyku C pri celých číslach so znamienkom vedú k nedefinovanému správaniu, sa v jazyku Swift zachytávajú ako chyba počas behu programu. Programátori môžu pretečenie povoliť použitím špeciálnych aritmetických operátorov &+, &-, &*, &/ a &%. Vlastnosti min a max sú v jazyku Swift definované pre všetky celočíselné typy a možno ich použiť na bezpečnú kontrolu možných pretečení namiesto spoliehania sa na konštanty definované pre každý typ v externých knižniciach.
  • Jednopríkazová forma príkazov if a while, ktorá umožňuje vynechať zložené zátvorky okolo príkazu, nie je podporovaná.
  • Enumerácia v štýle jazyka C for (int i = 0; i < c; i++), náchylná na chyby o jedna (angl. off-by-one), nie je podporovaná (od verzie Swift 3).
  • Operátory pre- a postinkrementácie a dekrementácie (i++, --i …) nie sú podporované (od verzie Swift 3), o to viac, že od verzie Swift 3 nie sú podporované ani príkazy for v štýle jazyka C.

Vývoj a ďalšie implementácie

Keďže Swift beží aj na Linuxe, niekedy sa používa aj ako jazyk na strane servera. Vzniklo niekoľko webových rámcov, napríklad Kitura spoločnosti IBM (už ukončený), Perfect, Vapor a Hummingbird.

Apple založil aj oficiálnu pracovnú skupinu „Server APIs“, v ktorej majú ústrednú úlohu členovia komunity vývojárov jazyka Swift.

Druhá slobodná implementácia jazyka Swift, ktorá je zameraná na Cocoa, platformu Common Language Infrastructure spoločnosti Microsoft (.NET Framework, dnes .NET) a na platformy Java a Android, existuje ako súčasť kompilátora Elements Compiler spoločnosti RemObjects Software.

Podmnožiny jazyka Swift boli portované na ďalšie platformy, napríklad na Arduino a Mac OS 9.

Pozri aj

• Objective-C
• D (programovací jazyk)
• Kotlin (programovací jazyk)
• Python (programovací jazyk)
• Zoznam programovacích jazykov

Iné projekty

Commons

• Commons ponúka multimediálne súbory na tému Swift (programovací jazyk)

Externé odkazy

• Oficiálna stránka (po anglicky)
• Swift na stránke Apple Developer (po anglicky)
• Zdrojový kód jazyka Swift na platforme GitHub (po anglicky)

Zdroj

Tento článok je čiastočný alebo úplný preklad článku Swift (programming language) na anglickej Wikipédii. Tento článok je čiastočný alebo úplný preklad článku Callable object na anglickej Wikipédii.