Swift

Syntaxen er enkel og effektiv, designet til både høj ydeevne og læsevenlighed. Swift kombinerer avancerede funktioner som typeinferens og mønstermatching med en letforståelig struktur, der gør kode lettere at vedligeholde.

Swift udvikler sig konstant med nye funktioner og er ideelt til alt fra simple projekter til komplekse systemer.

Basic Operators:

En operator er et specielt symbol eller udtryk, som bruges til at tjekke, ændre eller kombinere værdier. For eksempel lægger additionsoperatoren (+) to tal sammen, som i let i = 1 + 2, og den logiske OG-operator (&&) kombinerer to boolske værdier, som i if enteredDoorCode && passedRetinaScan.

Swift bruger de samme typer operatorer som C, men gør dem smartere for at undgå typiske fejl. For eksempel giver tildelingsoperatoren (=) ikke noget resultat, så man ikke kommer til at bruge den i stedet for lighedsoperatoren (==). De matematiske operatorer (+, -, *, /, %, osv.) opdager, hvis der sker et overflow, hvor tal bliver for store eller små til at passe i deres datatype. Hvis et overflow skal tillades, kan man bruge Swifts specielle overflow-operatorer. 

Swift har også nogle smarte rækkeviddeoperatorer, som ikke findes i C. For eksempel kan du bruge a..<b og a...b til hurtigt at angive en række værdier.

Terminologi:

Der findes tre typer operatorer: unary, binary og ternary.

Unary operatorer arbejder med én enkelt værdi. Unary prefix operatorer står lige foran værdien, som i !b, mens unary postfix operatorer står lige efter, som i c!.

Binary operatorer arbejder med to værdier, som i 2 + 3, og de placeres mellem dem (derfor kaldes de infix operatorer).

Ternary operatorer arbejder med tre værdier. Ligesom i C har Swift kun én ternary operator, nemlig den ternary conditional operator (a ? b : c).

De værdier, som operatorer påvirker, kaldes operands. I udtrykket 1 + 2 er symbolet + en infix operator, og værdierne 1 og 2 er dens operands.

Collection types:

Swift har tre hovedtyper af samlinger, der hedder arrays, sets og dictionaries, som du kan bruge til at gemme flere værdier. Arrays er ordnede samlinger af værdier, sets er uordnede samlinger af unikke værdier, og dictionaries er uordnede samlinger af nøgle-værdi-par.

I Swift er det altid tydeligt, hvilke typer værdier og nøgler der kan gemmes i arrays, sets og dictionaries. Det betyder, at du ikke kan komme til at tilføje en værdi af en forkert type ved en fejl. Samtidig kan du være sikker på, hvilken type værdier du får ud af en samling, når du arbejder med den.

Sets:

Et set gemmer forskellige værdier af samme type i en samling uden nogen bestemt rækkefølge. Man kan bruge et set i stedet for et array, når rækkefølgen på elementerne ikke betyder noget, eller når man vil sikre, at et element kun optræder én gang.

Hash-værdier for set-typer

For at en type kan gemmes i et set, skal den være hashable, hvilket betyder, at den skal kunne generere en hash-værdi for sig selv. En hash-værdi er et heltal (Int), der er det samme for alle objekter, der er ens. Hvis for eksempel a == b, skal hash-værdien for a være den samme som hash-værdien for b.

Alle de grundlæggende typer i Swift (som String, Int, Double og Bool) er hashable som standard og kan bruges som værdier i sets eller som nøgler i dictionaries. Enum-typer uden tilknyttede værdier (som beskrevet i Enumeration) er også hashable som standard.

Man kan bruge sine egne brugerdefinerede typer som værdityper i sets eller som nøgler i dictionaries ved at få dem til at overholde Hashable-protokollen fra Swift-standardbiblioteket.

Set-type-syntaks

En Swift set-type skrives som Set<Element>, hvor Element er den type, som set’et må indeholde. I modsætning til arrays har sets ikke en kortere skrivemåde.

Funktions

Funktioner er små bider af kode, der udfører en specifik opgave. Man giver en funktion et navn, der beskriver, hvad den gør, og dette navn bruges til at “kalde” funktionen, når man har brug for at udføre dens opgave.
Swift’s funktion-syntaks er fleksibel, så man kan skrive alt fra en simpel funktion uden parameternavne, til en mere kompleks Objective-C-style metode med navne og etiketter for hver parameter. Parametre kan også have standardværdier, hvilket gør det lettere at kalde funktionen, og de kan sendes som in-out parametre, der ændrer på en variabel, når funktionen er færdig med at køre.

Hver funktion i Swift har en type, som består af dens parameter-typer og retur-type. Denne type kan bruges ligesom andre typer i Swift, hvilket gør det nemt at sende funktioner som parametre til andre funktioner, eller returnere funktioner fra funktioner. Funktioner kan også skrives inden i andre funktioner for at holde funktionalitet samlet i en indre funktion.

Definere og Kalde Funktioner

Når man definerer en funktion, kan man vælge at definere en eller flere navngivne værdier, som funktionen tager som input, kaldet parametre. Man kan også vælge at definere en type for den værdi, funktionen sender tilbage som output, kaldet dens retur-type.
Hver funktion har et navn, som beskriver, hvad funktionen gør. For at bruge en funktion, “kalder” man den ved dens navn og sender den input-værdier (kaldet argumenter), som passer til funktionens parametre. Argumenterne skal altid sendes i den samme rækkefølge som parametrene i funktionen.

Swift vs C#

• Swift: Funktioner i Swift kan defineres globalt, udenfor en hvilken som helst type (klasse, struktur eller enum). De er ikke bundet til en specifik type. Man definerer dem ved at bruge func-nøgleordet.

  C#: Funktioner i C# er altid metoder, hvilket betyder, at de altid defineres indenfor en klasse, struktur eller interface. Der findes ikke en direkte ækvivalent til Swift’s uafhængige funktioner. Dog kan man definere statiske metoder, der ikke er bundet til en instans af en klasse, men de tilhører stadig en type.

Methods

Metoder er funktioner, der er knyttet til en bestemt type. I Swift kan klasser, strukturer og enumerationer definere instansmetoder, som indeholder specifikke opgaver og funktioner til at arbejde med en instans af en given type. Klasser, strukturer og enumerationer kan også definere type-metoder, som er knyttet til selve typen. Type-metoder minder om klassemetoder i Objective-C.
En stor forskel mellem Swift og C/Objective-C er, at strukturer og enumerationer også kan definere metoder i Swift. I Objective-C kan kun klasser definere metoder, men i Swift kan man vælge at definere en klasse, struktur eller enumeration, og stadig have muligheden for at definere metoder for den type, man opretter.

Instansmetoder

Instansmetoder er funktioner, der tilhører instanser af en bestemt klasse, struktur eller enumeration. De understøtter funktionaliteten af disse instanser, enten ved at give måder at få adgang til og ændre instansens egenskaber, eller ved at tilbyde funktionalitet, der relaterer sig til instansens formål. Instansmetoder har præcis den samme syntaks som funktioner.

Man skriver en instansmetode indenfor de åbne og lukkede krøllede parenteser af den type, den tilhører. En instansmetode har implicit adgang til alle andre instansmetoder og egenskaber for den type, den tilhører. En instansmetode kan kun kaldes på en specifik instans af den type, den tilhører. Den kan ikke kaldes alene uden at en instans eksisterer.

Metoder i Swift adskiller sig fra funktioner på den måde, at de altid er knyttet til en specifik type, og at man kun kan kalde instansmetoder på en instans af den type. Funktioner, derimod, kan defineres og kaldes frit uden at være knyttet til en type. Dette giver mere fleksibilitet i Swift, da både klasser, strukturer og enumerationer kan indeholde metoder, mens dette ikke er muligt i C og Objective-C, hvor kun klasser kan have metoder.

Swift vs C#

Instans- og statiske metoder: I C# er metoder enten instansmetoder (som tilhører en instans af en klasse eller struktur) eller statiske metoder (som er knyttet til selve typen). Statiske metoder i C# ligner Swift’s type metoder, men i C# er statiske metoder ikke kun begrænset til klasser – de kan også defineres i strukturer.

Syntax: C# metoder defineres også med en lignende syntaks som Swift-funktioner, men i C# er metoder altid indenfor en klasse- eller strukturdefinition. Der er ikke nogen adskillelse mellem metoder og funktioner som i Swift, fordi alt betragtes som en metode, når det tilhører en type.

Closures

Closures er selvstændige funktionalitetsblokke, der kan videregives og bruges i koden. Closures i Swift ligner closures, anonymous functions, lambdas og blocks i andre programmeringssprog.

Closures kan fange og gemme referencer til konstante værdier og variabler fra den kontekst, de er defineret i. Dette kaldes closing over disse konstante værdier og variabler. Swift håndterer al hukommelsesstyring af fangst for en.

• Globale funktioner er closures, der har et navn og ikke fanger nogen værdier.
• Indlejrede funktioner er closures, der har et navn og kan fange værdier fra deres omgivende funktion.
• Closure expressions er unavngivne closures skrevet i en letvægts-syntaks, der kan fange værdier fra deres omkringliggende kontekst.

Swift’s closure expressions har en ren, klar stil med optimeringer, der opmuntrer til kortfattet, rod-fri syntaks i almindelige scenarier. Disse optimeringer inkluderer:

• At udlede parameter- og returtype fra konteksten
• Implicitte returværdier fra enkeltudtrykte lukninger
• Kortfattede argumentnavne
• Trailing closure-syntaks

Closure expressions

Indlejrede funktioner,  er en praktisk måde at navngive og definere selvstændige kodeblokke som en del af en større funktion. Det kan nogle gange være nyttigt at skrive kortere versioner af funktion-lignende konstruktioner uden en fuld erklæring og et navn. Dette gælder især, når man arbejder med funktioner eller metoder, der tager funktioner som én eller flere af deres argumenter.
Closure expressions er en måde at skrive inline-closures på en kortfattet, fokuseret syntaks. Closure expressions tilbyder flere syntaksoptimeringer til at skrive closures i en forkortet form uden at miste klarhed eller hensigt.

Protokol-orienteret programmering (POP)

Swift Protokoller: Swift lægger stor vægt på Protokol-orienteret programmering (POP), som opfordrer til at bruge protokoller til at designe adfærd i stedet for at stole tungt på inheritance. I Swift kan protokoller bruges til at give delt adfærd på tværs af typer, og man kan udnytte protokol-udvidelser til at tilføje standardadfærd til flere typer på en måde, der efterligner class-based inheritance, men uden den tætte sammenkobling, der følger med class-based inheritance.
Swifts fokus på protokoller er en vigtig forskel fra andre sprog som C#, som ofte læner sig mere op ad inheritance og class-based tilgange til at dele adfærd.