Einführung in Swift 2 - mitp

Inhaltsverzeichnis
Einleitung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
1
1.1
1.2
1.3
1.4
1.5
1.6
1.7
1.8
Datentypen und Optionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Willkommen auf dem Spielplatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Variablen und Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zahlendatentypen konvertieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Werte runden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Minimum und Maximum. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Datentyp Bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Optionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programmieren mit Optionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
21
23
30
33
35
36
37
40
2
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
Zeichenketten des Typs String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
String-Interpolation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zeichenketten vergleichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Textabschnitte finden und ersetzen . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zeichenketten in Zahlentypen konvertieren . . . . . . . . . . . . . . . . . . . .
Die Klasse NSNumber . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Texte teilen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Subscripting mit Unicode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Anfang und Ende von Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . .
43
45
47
50
54
57
58
61
63
3
3.1
3.2
3.3
3.4
Arrays und Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Arrays – Listen von Elementen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Arrays sortieren und filtern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dictionaries, die schnellen Wörterbücher . . . . . . . . . . . . . . . . . . . . . .
Arrays aus Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
67
71
75
79
4
4.1
4.2
4.3
4.4
4.5
Fallunterscheidungen und Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . .
Die if-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die switch-case-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Schleifen und Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückwärts durch die for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
81
81
88
92
95
96
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
5
Inhaltsverzeichnis
6
4.6
4.7
4.8
4.9
Die while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Schleifen mit Fallunterscheidungen . . . . . . . . . . . . . . . . . . . . . . . . . .
Werte als Diagramme anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gültigkeitsbereiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
98
100
103
105
5
5.1
5.2
5.3
5.4
5.5
5.6
5.7
5.8
Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die erste Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Benannte Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Funktionen mit Rückgabewert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tupel und anonyme Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Eine unbestimmte Anzahl von Parametern. . . . . . . . . . . . . . . . . . . . .
Funktionen mit Standardwerten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Parameter sind unveränderlich. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aliasse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
111
111
116
118
121
125
128
131
133
6
6.1
6.2
6.3
6.4
6.5
6.6
6.7
Closures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Closures sind Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Closures als Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Arrays sortieren mit Closures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Variablen einfangen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Asynchrone Closures mit Grand Central Dispatch . . . . . . . . . . . . . . .
Parallele Verarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Asynchrone Aufrufe mittels Completion-Handler . . . . . . . . . . . . . . .
137
137
139
145
150
153
157
159
7
7.1
7.2
7.3
7.4
7.5
7.6
7.7
Klassen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das erste Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Erste Schritte im Workspace-Fenster . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Klasse Person . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Von der Klasse zum Objekt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Eigenschaften und Punktnotation . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Berechnete Eigenschaften mit Getter und Setter . . . . . . . . . . . . . . . .
Eigenschaften beobachten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
163
163
166
171
173
175
176
180
8
8.1
8.2
8.3
8.4
8.5
Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Methoden zur Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Failable-Initializers – Wenn es mal schiefgeht . . . . . . . . . . . . . . . . . .
Methoden zu Deinitialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Klassenmethoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Methoden kontra Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
187
190
194
196
197
200
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
Inhaltsverzeichnis
9
9.1
9.2
9.3
9.4
9.5
9.6
9.7
Vererbung und Assoziationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das Erbe der Klasse Person . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Erweiterungen der abgeleiteten Klasse . . . . . . . . . . . . . . . . . . . . . . . .
Methoden überschreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Initialisierung abgeleiteter Klassen . . . . . . . . . . . . . . . . . . . . . . . .
Assoziationen – Beziehungen zwischen Objekten . . . . . . . . . . . . . . .
Optional-Chaining . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Coalescing-Operator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
203
203
207
208
211
215
221
224
10
10.1
10.2
10.3
10.4
10.5
Protokolle und Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein eigenes Protokoll entwickeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Protokolle statt Datentypen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Optionale Protokolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Extensions mit Protokollen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
227
228
231
234
237
240
11
11.1
11.2
11.3
11.4
11.5
Strukturen und Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zurück zum Spielplatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Strukturen oder Klassen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
String Dependencies – Abhängigkeiten von Zeichenketten . . . . . . .
Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Enumerationen mit Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
243
243
247
251
252
255
12
12.1
12.2
12.3
12.4
Sicherer Programmcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Funktionen absichern mit guard . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fehler werfen mit throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fehler auffangen mit catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
259
259
262
264
266
13
13.1
13.2
13.3
Speicherverwaltung mit Referenzzähler . . . . . . . . . . . . . . . . . . . . . . .
Automatic Reference Counting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Starke und schwache Referenzen. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zirkelverweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
269
272
273
274
14
14.1
14.2
14.3
14.4
Lotto – 6 aus 49. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
MVC: Model – View – Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Projektvorlage – Cocoa Application . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Lottozahlengenerator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Interface Builder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
277
277
279
282
289
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
7
Inhaltsverzeichnis
8
14.5
14.6
14.7
14.8
14.9
14.10
Inspector und Bibliothek. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Arbeiten mit dem Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zurück zum Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das war es jetzt schon? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
One more thing ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
290
292
297
301
305
306
A
Swift-Lexikon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
309
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
337
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
Kapitel 1
Datentypen und Optionals
Im grundlegenden Umgang mit Variablen und Werten sind sich die
meisten modernen Programmiersprachen sehr ähnlich und unterscheiden sich oft nur in der verwendeten Syntax. Swift ist dabei keine
Ausnahme, und wenn Sie schon mit anderen Sprachen gearbeitet
haben, wird Ihnen der Inhalt der nächsten Seiten bestimmt vertraut
vorkommen. Trotzdem sollten Sie dieses Kapitel nicht überspringen,
denn Swift bietet einige Besonderheiten und Anweisungen, die man in
anderen Sprachen nicht findet. Selbst von einfachen und alltäglichen
Dingen, wie zum Beispiel der Addition von Variablen, können erfahrene Entwickler durch Swift noch überrascht werden. Lassen auch Sie
sich also überraschen!
1.1
Willkommen auf dem Spielplatz
Xcode bietet in der aktuellen Version einen besonderen Dokumententyp, der als »Playground«, englisch für Spielplatz, bezeichnet wird.
Wenn Sie in einem Playground Programmcode schreiben, wird Ihnen
das Ergebnis Ihrer Arbeit oft sofort in einer Seitenleiste neben dem Texteditor angezeigt, die von Apple als Results Sidebar bzw. als Ausgabebereich bezeichnet wird. Dort können Sie leicht überprüfen, ob die
eingegebenen Anweisungen korrekt sind und das gewünschte Ergebnis liefern. Der Spielplatz eignet sich hervorragend, um neue Dinge
auszuprobieren und zu testen, oder sich – wie in unserem Fall – mit
Swift vertraut zu machen.
Einen neuen Playground können Sie direkt vom Welcome-to-XcodeFenster aus erstellen, welches beim Start der Entwicklungsumgebung
angezeigt wird. Wählen Sie dort GET STARTED WITH A PLAYGROUND.
Möchten Sie zu einem bereits bestehenden Projekt einen Playground
hinzufügen, führt der Weg über die Menüpunkte FILE, NEW und FILE...
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
21
Kapitel 1
Datentypen und Optionals
Ein Playground der Plattform iOS unterschiedet sich von einem OS-XSpielplatz nur durch die Anweisung, mit der das zugehörige Framework für die grafischen Oberflächen importiert wird. iOS-Apps arbeiten mit UIKit, während für OS X das Cocoa Framework importiert
wird. Für unsere ersten Schritte benötigen wir jedoch nur das Foundation-Framework und somit ist es egal, für welche Plattform Sie den
Playground erzeugen. Foundation ist sowohl in UIKit, als auch in
Cocoa enthalten. Nennen Sie Ihren ersten Playground Datentypen
und speichern Sie die Datei an einem Ort, an dem Sie diese später
leicht wiederfinden. Sie sollten immer bemüht sein, ihre Projekte gut
zu organisieren, um die Übersicht nicht zu verlieren und Dinge schnell
finden zu können.
22
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
1.2
Variablen und Konstanten
Nachdem Xcode den Playground angelegt hat, öffnet die Entwicklungsumgebung ein in zwei Bereiche geteiltes Fenster. Die linke Seite ist der
Editor, in den wir unsere Anweisungen schreiben können. Die rechte
Seite wird als Ausgabebereich bezeichnet und dient zur Ausgabe von
Werten und Variablen. Neben der import-Anweisung und einem Kommentar gibt es im Programm sogar schon einen Befehl. Mit
var str = "Hello, playground"
wird der Variablen str der Text Hello, playground zugewiesen, der
daraufhin im Ausgabebereich angezeigt wird. Da wir uns mit Texten
erst später beschäftigen, können Sie die Anweisung entfernen.
Löschen Sie aber nicht versehentlich den import-Befehl. Ohne ein
geladenes Framework kann es in einem Swift-Programm zu verwirrenden Fehlermeldungen kommen, deren wahre Ursache nur schwer zu
erkennen ist.
1.2
Variablen und Konstanten
Lassen Sie uns bei der Reise in die Welt der Swift-Programmierung mit
etwas ganz Einfachem beginnen. Wie alle modernen Programmiersprachen bietet Swift die Möglichkeit, im Programmcode Variablen zu
deklarieren und ihnen Werte zuzuweisen. Der von Xcode vorbereitete
Playground hat das mit seiner Anweisung schon gut demonstriert. Für
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
23
Kapitel 1
Datentypen und Optionals
verschiedene Anwendungsfälle kommen dabei dann unterschiedliche
Datentypen zum Einsatz. Soll mit den Werten gerechnet werden, fällt
die Wahl in der Regel auf die Typen Int, Double oder Float, je nach
der erforderlichen Genauigkeit. Das nachfolgende kurze Listing zeigt
beispielhaft die Definition zweier Variablen mit dem Befehl var und
zwei unterschiedlichen Datentypen. Wenn Sie alle Anweisungen richtig eingegeben haben, wird Xcode im Ausgabebereich des PlaygroundFensters die Inhalte der Variablen anzeigen. An dieser Stelle erneut der
Hinweis, dass die Anweisungen auch funktionieren, wenn Sie die
Befehlszeilen aus Gewohnheit mit einem Semikolon abschließen.
var age:Int = 43
var taxRate:Double = 9.5
Um welche Typen es sich bei den Variablen in unserem Code handelt,
können Sie vermutlich auch ohne jahrelange Erfahrung in der Softwareentwicklung und ohne die explizite Angabe des Typs schnell selbst
erkennen. Die Variable age ist eine ganze Zahl, ein so genannter Integer. Bei taxRate finden wir Nachkommastellen, sodass es sich um
eine Dezimalzahl handeln muss. Dort sollten dann der Typ Double
oder Float verwendet werden, denn als ganze Zahl ließe sich dieser
Wert nur unvollständig ablegen.
24
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
1.2
Variablen und Konstanten
Wichtig
Für Variablennamen wird in Swift die Lower-Camel-Case-Schreibweise
verwendet. Der erste Buchstabe im Namen ist ein kleiner Buchstabe, alle
weiteren Wörter, aus denen der Name gebildet wird, beginnen mit
einem Großbuchstaben. Beispiele für aussagekräftige Namen wären
arrayOfSelectedItems oder firstDayInMonth. Unterstriche in
Bezeichnern sind in Swift nicht üblich.
Wie Sie sicher bestätigen können, geben die Werte selbst schon genau
vor, welcher Datentyp verwendet werden muss, und so ist es in Swift
oftmals gar nicht notwendig, den Typ einer Variablen bei der Definition
explizit anzugeben. Der Compiler kann den Typ selbst erkennen. Die
Definitionen der beiden Variablen würden in Swift daher auch so funktionieren:
var age = 43
var taxRate = 9.5
Diese automatische Typerkennung des Compilers, die in der englischen Dokumentation als »Type Inference« bezeichnet wird, funktioniert in Swift sehr gut, sodass bei den meisten Variablen auf eine
explizite Angabe des Datentyps verzichtet wird. Als Entwickler kann
man jedoch sicher sein, dass der Compiler den richtigen Typ auswählt.
Außerdem wird der Programmcode so kürzer und besser lesbar, worauf man bei Apple sehr viel Wert legt.
Für das Programm selbst ändert sich dabei jedoch nichts. Die Variable
age ist weiterhin eine ganze Zahl und für Dezimalbrüche wie taxRate
wählt der Compiler immer den Typ Double, weil dieser im Vergleich
zu Float über eine größere Genauigkeit verfügt. Bei beiden Variablen
wird der Typ aus den zuerst zugewiesenen Werten ermittelt. Spätere
Änderungen auf einen anderen Typ sind nicht möglich. Wurde eine
Variable als Int festgelegt, können Sie ihr anschließend keine Zeichenkette zuweisen. Das folgende Beispiel wird nicht funktionieren, wie Sie
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
25
Kapitel 1
Datentypen und Optionals
in Ihrem Playgound leicht ausprobieren können. Durch Anklicken des
Fehlersymbols links neben dem Programmcode können Sie die Fehlermeldung ein- oder ausblenden.
var age = 43
var taxRate = 9.5
age = "19"
Die Deklaration und Definition einer Variablen muss in Swift keineswegs immer in einer Programmzeile geschehen, die Anweisungen
können auf mehrere Zeilen verteilt werden. Jetzt ist der Compiler
jedoch nicht mehr in der Lage, den Typ der Variablen selbstständig zu
erkennen und benötigt unsere Hilfe. Der Typ muss bei der Deklaration
wieder explizit angegeben werden.
var age:Int
var taxRate:Double
age = 43
taxRate = 9.5
Wie groß der Wert einer Variablen sein kann, hängt teilweise von der
Systemarchitektur ab, auf der das Programm ausgeführt wird. Auf
einem 32-Bit-System wird für den Typ Int ein 32 Bit langes Daten-
26
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
1.2
Variablen und Konstanten
wort verwendet, das den möglichen Wert auf einen Bereich von
-2.147.483.648 bis 2.147.483.647 eingrenzt. Auf Systemen mit einer
64-Bit-Architektur ist Int ein 64 Bit langes Datenwort und kann Werte
zwischen -9.223.372.036.854.775.808 und 9.223.372.036.854.775.807
annehmen. Werden explizit kleinere oder größere Datenworte benötigt, können statt Int die Datentypen Int8, Int16, Int32 und Int64
verwendet werden. Der Typ Float ist auf jedem System ein 32-BitDatenwort, Double hingegen immer 64 Bit lang. Welche Werte auf
Ihrem System möglich sind, können Sie mit den folgenden vier Aufrufen der print-Funktion herausfinden.
// Der größe Int-Wert
print(Int.max)
// Der kleinste Int-Wert
print(Int.min)
// Der größte Double-Wert
print(DBL_MAX)
// Der kleinste Double-Wert
print(DBL_MIN)
Ein Aufruf der Funktion print in einem Playground führt zu einer
Ausgabe in der Results Sidebar. Dort wird der Wert direkt neben der
zugehörigen Anweisung angezeigt. Der Ausgabebereich ist jedoch
nicht der einzige Ort, an dem die Entwicklungsumgebung die Ausgaben von print anzeigt, zusätzlich werden sie in die Konsolenansicht
geschrieben. Diese ist in der Standardkonfiguration eines Playgrounds
allerdings immer unsichtbar und muss erst eingeblendet werden. Die
Schaltfläche HIDE OR SHOW THE DEBUG AREA aus der Symbolleiste erledigt das. In der Konsole stehen die minimalen und maximalen Werte
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
27
Kapitel 1
Datentypen und Optionals
nicht neben den Anweisungen, sondern erscheinen in der Reihenfolge,
in der sie mit print ausgegeben wurden.
In Xcode-Projekten für iOS-Apps oder OS-X-Anwendungen steht
Ihnen während der Entwicklung kein Ausgabebereich zur Verfügung,
und Ihre Anweisungen werden dort auch nicht automatisch sofort nach
der Eingabe ausgeführt. Das funktioniert nur im Playground. Die Konsolenansicht gibt es jedoch auch dort und kann für Ausgaben genutzt
werden. Zögern Sie nicht, print zu verwenden, um den Programmablauf ihrer Anwendungen nachzuvollziehen oder Werte anzuzeigen.
Ein Aufruf von print verrät Ihnen nicht selten schneller etwas über
Ihr Programm als die Analysewerkzeuge der Entwicklungsumgebung.
Wenn Sie den Mauspfeil auf einen Wert im Ausgabebereich bewegen,
werden dort die Schaltflächen für Inline Results und Quick Look sichtbar. Beide Funktionen bieten weitere Möglichkeiten, den Wert einer
Variablen im Playground auszugeben. Aktivieren Sie ein Inline Result,
wird der Wert direkt im Codeeditor eingeblendet. Quick Look zeigt den
Wert in einem kleinen Fenster, welches jedoch sofort wieder verschwindet, sobald ein beliebiger anderer Punkt auf dem Bildschirm
angeklickt wird. Die Ausgabe eines Inline Results bleibt sichtbar, bis sie
wieder deaktiviert wird.
Während Variablen zur Laufzeit eines Programms jederzeit neue
Werte, allerdings nur desselben Typs, zugewiesen werden können, ist
dies bei Konstanten nicht möglich. Konstanten werden in Softwareprojekten daher oft zur Konfiguration eingesetzt, um Werte einer Anwen-
28
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
1.2
Variablen und Konstanten
dung leichter zu verwalten und »Magische Zahlen« zu vermeiden.
Dabei handelt es sich um Zahlenwerte, die direkt im Programmcode
stehen und deren Aufgaben oft nur schwer erkennbar sind. Eine Konstante mit einem aussagekräftigen Namen kann dann sehr zur Lesbarkeit des Codes beitragen.
In Swift werden Konstanten über den Befehl let erzeugt. Das nachfolgende Listing zeigt die Definition der Zahl Pi sowie einer Serveradresse
als Zeichenkette.
let pi = 3.14159265359
let server = "http://cocoa-coding.de"
In den ersten Versionen von Swift war es bei einer Konstanten nicht
möglich, Deklaration und Definition auf mehrere Programmzeilen zu
verteilen, das funktionierte selbst dann nicht, wenn der Typ explizit
angegeben wurde. Seit Swift 2 können Deklaration und Definition
getrennt werden, in vielen anderen Programmiersprachen funktioniert
das bei Konstanten nicht.
let pi:Double
pi = 3.14159265359
let server:String
server = "http://cocoa-coding.de"
Eine nachträgliche Änderung des zugewiesenen Wertes ist anschließend nicht mehr möglich. Eine Konstante ist unveränderlich, und der
Compiler wird bei dem Versuch, Änderungen vorzunehmen, Fehlermeldungen ausgeben.
Wichtig
Swift und Xcode erlauben bei der Entwicklung die Verwendung sämtlicher Unicode-Zeichen als Variablennamen. So können Sie beispielsweise statt des Variablennamens pi auch das Zeichen U+30C0 (Greek
Small Letter Pi) verwenden.
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
29
Kapitel 1
Datentypen und Optionals
Inwieweit dies die Programmierung leichter und übersichtlicher
macht, sollten Sie für sich selbst entscheiden. Empfehlen kann man
diese Vorgehensweise vermutlich nur in Ausnahmefällen.
let  = 3.14159265359
1.3
Zahlendatentypen konvertieren
Nicht selten gibt es in Programmen Situationen, bei denen die Inhalte
von mehreren Variablen zu einem Wert zusammengefasst werden
müssen. Ein sehr gutes Beispiel sind mathematische Berechnungen,
die aus einzelnen Werten ein Ergebnis ermitteln. Swift unterscheidet
sich dabei nicht von anderen Programmiersprachen und unterstützt
eine Vielzahl von Rechenoperatoren. Wie nicht anders zu erwarten, gilt
immer Punkt- vor Strichrechnung.
var a = 75
var b = 100
var c = 5
let sum1 = a + b * c
let sum2 = (a + b) * c
Beachtenswert im gezeigten Beispiel ist der Umstand, dass auch das
Ergebnis einer Berechnung einer Konstanten zugewiesen werden
kann. Im Unterschied zu einigen anderen Programmiersprachen
muss der Wert einer Konstanten in Swift nicht zwangsläufig während
der Kompilierung bekannt sein, obwohl er sich in diesem Beispiel
durchaus ermitteln ließe. Sogar eine Textfeldeingabe, die erst nach
dem Start der Anwendung vorgenommen wird, kann in Swift einer
Konstanten zugewiesen werden.
Solange wir uns bei den Rechenoperationen auf nur einen Datentyp
beschränken, können wir ohne Probleme programmieren. Schwierig
wird es erst, wenn unterschiedlichen Typen verwendet werden. Dann
kann schon eine einfache Addition zu Problemen führen:
30
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
1.3
Zahlendatentypen konvertieren
var a = 75
var b = 3.8
// Die Addition unterschiedlicher Datentypen
// führt zu einer Fehlermeldung!
let sum = a + b
Auch ohne Angabe eines Typs können wir die Variable a als ganze Zahl
und somit vom Typ Int identifizieren. Bei b hingegen handelt es sich
um eine Dezimalzahl, für die der Swift-Compiler dann einen DoubleTyp verwendet, sofern ihr Typ nicht explizit als Float angegeben wird.
Doch welchen Typ muss man einsetzen, wenn die beiden Variablen
addiert werden sollen? Mit einem weiteren Double wäre sichergestellt,
dass der Nachkommateil der Summe nicht verloren geht, aber in
machen Situationen ist vielleicht genau das gewünscht und man
möchte nur ganze Zahlen. Weil der Swift-Compiler diese Entscheidung
nicht eigenständig treffen kann, führt die Addition zu einem Fehler.
Schuld daran sind die unterschiedlichen Datentypen. Leider ist die
Meldung der Entwicklungsumgebung nicht besonders aussagekräftig,
wenn man mit der Problematik nicht vertraut ist:
In der Softwareentwicklung unterscheidet man zwei Arten der Typkonvertierung. Bei der impliziten Konvertierung entscheidet der Compiler
selbstständig, welcher Typ verwendet werden soll. Bei einer Berechnung, die sowohl Int als auch Double-Typen verwendet, würde vermutlich ein Double für das Ergebnis verwendet, um eine bestmögliche
Genauigkeit zu gewährleisten. Allerdings gibt es keine Regel, dass dies
so sein muss, und Programmiersprachen mit anderen Compilern können sich anders verhalten. Damit der Entwickler sich nicht auf Vermutungen verlassen muss, ist in Swift eine implizite Konvertierung nicht
möglich. Die gezeigte Fehlermeldung ist die Folge.
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
31
Kapitel 1
Datentypen und Optionals
Bei einer expliziten Konvertierung muss der gewünschte Typ im Programm genau festgelegt werden, was somit zu einer Aufgabe für uns
Programmierer wird. Soll das Ergebnis vom Typ Double sein, müssen
wir den Compiler anweisen, die Variable a vor der Addition mithilfe
einer Funktion in einen Double-Typ zu konvertieren. Sind beide Summanden vom gleichen Typ, ergibt sich der Typ für die Summe.
// Die Double-Funktion:
// a wird zunächst in einen Double-Typ umgewandelt
// c wird so zu einem Double-Typ
var sumDouble = Double(a) + b
Wollen wir unser Ergebnis lieber als ganze Zahl, muss die Variable b
konvertiert werden. Doch Vorsicht, gerundet wird die Zahl von der IntFunktion nicht! Die Nachkommastellen werden abgeschnitten, aus 3,8
wird 3 und die Summe der Addition somit 78! Mit einer expliziten Konvertierung erhalten wir immer den gewünschten Typ und sind nicht
von der Entscheidung eines Compilers abhängig.
// Die Int-Funktion:
// b wird zunächst in einen Int-Typ umgewandelt
// c wird so zu einem Int-Typ
var sumInt = a + Int(b)
Die gezeigten Arten der Konvertierung entsprechen einer Umwandung, die als »cast« oder »typecasting« bezeichnet wird, in Swift allerdings mit einer etwas ungewöhnlichen Syntax. Viele andere
Programmiersprachen verwenden eine Schreibweise, bei der dem zu
konvertierenden Wert der gewünschte Typ in runden Klammern vorangestellt wird. Dort sieht es so aus:
// Typecasting, wie es in anderen Sprachen
// angewendet wird.
// var sum = (Double)a + b
32
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
1.4
Werte runden
Möchte man in einem Swift-Programm zwei Int-Werte addieren, das
Ergebnis aber als Double erhalten, ist das ebenfalls nur ein kleines Problem. In den runden Klammern der Funktionen kann die Addition programmiert werden. So ist es nicht erforderlich, beide ganze Zahlen
einzeln zu konvertieren.
var x = 100
var y = 60
// Einzelne Konvertierung, nicht erforderlich
// var sum = Double(x) + Double(y)
// Konvertierung der Summe
var sum = Double(x + y)
1.4
Werte runden
Bei einer expliziten Konvertierung von Double zu Int sämtliche Nachkommastellen abzuscheiden, kann gewünscht sein, doch nicht weniger oft möchte man den Wert zuvor runden. Diese Aufgabe kann die
Funktion round übernehmen. Wie Sie mit den folgenden Anweisungen selbst ausprobieren können, wird ab einem Nachkommawert von
.5 aufgerundet, ansonsten wird abgerundet.
var a1 = 99.49
var r1 = round(a1)
// r1 ist jetzt 99.0
var a2 = 99.50
var r2 = round(a2)
// r2 ist jetzt 100.0
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
33
Kapitel 1
Datentypen und Optionals
Soll der gerundete Wert dann zu einem Int–Typ werden, spricht
nichts dagegen, verschiedene Anweisungen zu verschachteln. So kann
man im Code eine Zeile einsparen, ohne dabei allzu viel Lesbarkeit
einzubüßen.
var a2 = 99.50
var r2 = Int(round(a2))
// r2 ist jetzt 100 und vom Typ Int
Zwei weitere wichtige Funktionen zur Manipulation von Double-Werten
sind floor und ceil. Sie liefern den nächstniedrigeren und nächsthöheren ganzzahligen Wert, vollkommen unabhängig vom Wert hinter
dem Komma. Das Ergebnis ist weiterhin ein Double.
var aValue = 99.001
var c = ceil(aValue)
// c ist jetzt 100.0
var f = floor(aValue)
// f ist jetzt 99.0
Einige Entwickler, die ich kennengelernt habe, hatten Schwierigkeiten,
sich die Funktionsweisen von floor und ceil zu merken und diese zu
unterscheiden. Denken Sie dabei an die englischen Begriffe. floor ist
der Fußboden und somit der niedrige, untere Wert. ceil ist eine
Abkürzung für ceiling, die Zimmerdecke. Bei dieser Funktion bekommen wir den höheren, oberen Wert. Die Zimmerdecke ist oben und der
Fußboden ist unten. Ganz einfach!
34
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
1.5
Minimum und Maximum
1.5
Minimum und Maximum
Wird der kleinere oder der größere Wert zweier Zahlen benötigt, kann
man dies mit einer if-Struktur sicherlich leicht programmieren. Etwas
eleganter sind die in Swift bereits vorhandenen Funktionen max und min.
var m1 = 1234
var m2 = 9876
// Den größeren und den kleineren Wert zweier
// Int-Typen ermitteln
var maximum = max(m1,m2)
var minimum = min(m1,m2)
Eine besondere Erklärung ist an dieser Stelle vermutlich nicht nötig.
Erwähnenswert ist jedoch, dass die beiden Funktionen in Swift auch
mehr als zwei Werte verarbeiten können. Bei den ähnlichen Funktionen anderer Programmiersprachen ist das nicht möglich. Allerdings
müssen sämtliche Werte vom gleichen Typ sein, also ausschließlich
Double, Float oder Int.
var m1 = 12.34
var m2 = 98.76
var m3 = 87.88
var m4 = 666.6
// Den größten und den kleinsten Wert aus vier
// Double-Typen ermitteln
var maximum = max(m1,m2,m3,m4)
var minimum = min(m1,m2,m3,m4)
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
35
Kapitel 1
Datentypen und Optionals
Eine Alternative zu min und max bieten die beiden Funktionen
minElements und maxElements, die jedoch beide eine Auflistung des
Typs Array als Parameter erwarten. Mit diesen Listen werden wir uns
in Kapitel 3 noch genauer beschäftigen. Um die Funktionen auf unsere
vier Variablen anzuwenden, genügt es für den Augenblick, die Bezeichner zusätzlich in eckige Klammern einzufassen. Sämtliche Funktionen
akzeptieren neben Variablen und Konstanten auch feste Werte, die
unveränderlich im Programmcode stehen.
var minValue = minElement([m1, m2, m3, m4])
var maxValue = maxElement([4.5, 4.0, 3.9, 4.4])
1.6
Der Datentyp Bool
Einen Datentyp, den man in diesem Kapitel nicht unterschlagen sollte,
ist der Typ Bool, benannt nach dem englischen Mathematiker George
Boole. Eine Variable oder Konstante des Typs Bool kann ausschließlich
die Werte true oder false annehmen und wird deshalb fast ausnahmslos dazu verwendet, um eine bestimmte Aussage als wahr oder
unwahr zu kennzeichnen. Wenn wir uns in Kapitel 4 mit Fallunterscheidungen beschäftigen, wird der Typ Bool daher eine große Rolle
spielen.
// Zuweisungen boolscher Typen
// mit Angabe des Datentyps
var valueB1:Bool = true
// Ohne Angabe des Datentyps
var valueB2 = false
In einigen anderen Programmiersprachen kann ein Bool alternativ
durch Zahlenwerte gesetzt werden, wobei 0 einem false und jeder
andere Wert einem true entspricht. Weil so die Lesbarkeit des Codes
aber sehr beeinträchtigt wird, gibt es diese Möglichkeit seit Swift 2
nicht mehr. Die aus Objective-C bekannten Werte YES und NO funktionieren in Swift ebenfalls nicht.
36
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
1.7
Optionals
// Alternative Zuweisung von Zahlen
// Funktioniert seit Swift 2 nicht mehr
var value1:Bool = 1
var value2:Bool = 0
1.7
Optionals
Einer der größten Unterschiede zwischen Objective-C und Swift ist die
Möglichkeit, Variablen und Konstanten im Programmcode als Optional zu deklarieren und ihnen damit die Fähigkeit zu geben, alternativ
zu einem Wert den Zustand nil anzunehmen. Ein Optional ist nil,
wenn ihm noch kein Wert zugewiesen wurde oder sein Zustand explizit unbestimmt sein soll.
Haben Sie das alles sofort verstanden? Zugegeben, das klingt sehr technisch, aber so ist die Softwareentwicklung gelegentlich. Möchte man
Optionals an einem Beispiel aus dem Alltag erklären, muss man dafür
ein wenig ausholen:
Stellen Sie sich ein digitales Thermometer vor, dessen gemessene Temperatur von einer Software verwaltet und angezeigt werden soll. Im
Sommer erreicht das Thermometer Temperaturen von über 30 Grad,
im Winter hingegen Werte unter 0 Grad. So ergibt sich ein großer
Bereich von möglichen Temperaturen, wobei es sich immer um Dezimalzahlen handelt. In der Software scheint der Datentyp Double daher
bestens geeignet, die ermittelte Temperatur aufzunehmen und zur
Anzeige zu bringen. Wie Sie inzwischen wissen, müssen Variablen
und Konstanten aber mit einem Wert initialisiert werden, bevor man
das erste Mal lesend auf sie zugreifen kann. Es gibt Situationen, in
denen ebendies zu einem Problem wird.
Solange das Thermometer funktioniert, hat das Programm mit der
Temperatur und dem Typ Double keine Schwierigkeiten. Problematisch wird es erst, wenn das Thermometer ausfällt oder von der Software aus einem anderen Grund keine Daten mehr empfangen werden
können. Mit welcher Temperatur haben wir es dann zu tun und welcher Wert soll dann angezeigt werden?
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
37
Kapitel 1
Datentypen und Optionals
Eine Möglichkeit wäre es, die Variablen mit dem Wert 0 zu initialisieren und somit eine Temperatur von 0 Grad anzuzeigen, wenn keine
Messungen vorliegen, aber das ist keine gute Lösung. 0 Grad ist eine
der mögliche Temperaturen in unserem Bereich, und wenn im Programm mit diesem Wert gearbeitet wird, sollte man davon ausgehen
können, dass die Temperatur so gemessen wurde. Die Software benötigt zusätzliche Informationen darüber, ob ein gemessener Wert vorliegt, aber ein Zahlenwert des Typs Double kann darüber keine
Auskunft geben. Das Programm muss erweitert werden. Ob es sich bei
dem abgelegten Wert tatsächlich um eine gemessene Temperatur handelt, ließe sich mit einer zusätzlichen booleschen Variable abbilden.
Oder Sie verwenden einen Optional!
In Swift kann jeder Typ zu einem Optional werden, allerdings ist es bei
der Definition einer Variablen oder Konstanten erforderlich, diese
Erweiterung explizit anzugeben, denn dass eine Variable oder Konstante ein Optional sein soll, kann der Compiler nicht eigenständig
erkennen. Er würde immer einen regulären Typ einsetzen und sich
dann beschweren, wenn er für den Wert keine Zuweisung findet. Um
aus einem regulären Typ einen Optional zu machen, wird dem Datentyp ein Fragezeichen angehängt. So erfährt der Compiler, dass dieser
Wert nil sein darf.
Wenn Sie die zwei Anweisungen aus dem nächsten Listing in Ihrem
Playground eingeben, wird Ihnen Xcode für die Variable temperatur1
den Wert 32.5 im Ausgabebereich ausgeben. Für temperatur2 erhielten Sie in der Vergangenheit die Ausgabe {Some 32.5}, wobei Some ein
Hinweis auf einen Optional war. In der momentan aktuellen XcodeVersion wird das Some leider nicht mehr angezeigt.
// Definition einer Variablen
var temperatur1:Double = 32.5
// Definition einer Variablen als Optional
var temperatur2:Double? = 32.5
38
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
1.7
Optionals
Eindeutig werden die Informationen der Entwicklungsumgebung,
wenn Sie die beiden Variablen mit der print-Funktion ausgeben.
Zusätzlich zum Wert für temperatur2 wird jetzt das Wort Optional
angezeigt.
...
// Ausgabe der beiden Variablen
print(temperatur1)
print(temperatur2)
Besonders interessant verhält sich der Playground, wenn Sie für die
beiden Variablen die Zuweisungen der Werte entfernen. Die Variable
temperatur2 ist ein Optional und kann legitim ohne Wert verwendet
werden. Ihr Zustand ist dann automatisch nil, und genau das wird im
Ausgabebereich angezeigt, sobald man die Zuweisung entfernt.
// Definition einer Variablen
var temperatur1:Double = 32.5
// Definition einer Variablen als Optional
var temperatur2:Double?
// Ausgabe der beiden Variablen
print(temperatur1)
print(temperatur2)
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
39
Kapitel 1
Datentypen und Optionals
Löscht man die Zuweisung für die Variable temperatur1, kommt es
sofort zu einer Fehlermeldung. Eine reguläre Variable muss vor der
ersten Verwendung mit einem Wert initialisiert werden, sonst kann sie
nicht ausgegeben werden.
In Objective-C bekam man es mit nil zu tun, wenn ein Speicherzeiger
auf kein gültiges Objekt verwies, und das war nicht immer ein
gewünschter Zustand. In Swift ist nil bei einem Optional hingegen
ein legitimer Wert. Er sagt aus, dass es für die Variable keinen Wert
gibt. Um dies zu ermöglichen, muss der Typ aber explizit als Optional
gekennzeichnet werden. So kann der Entwickler bestimmen, welche
Variablen und Konstanten nil sein dürfen und welche nicht.
Programmieren mit Optionals
1.8
Den Programmcode, wie er in der Software unseres digitalen Thermometers zum Einsatz kommen könnte, zeigt das folgende Beispiel. Ist die
Variable temp gleich nil, wird der Text Keine Messung ausgegeben,
gibt es hingegen einen Wert, finden wir stattdessen die Temperatur im
Ausgabebereich. Probieren Sie das in Ihrer Entwicklungsumgebung
aus.
var temperatur:Double? = 18.2
if temperatur == nil
{
print("Keine Messung")
}
else
{
print(temperatur!)
}
40
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
1.8
Programmieren mit Optionals
Vereinfacht beschrieben, hat man es bei einem Optional immer mit
zwei Werten zu tun. Wird eine Variable oder Konstante mit ihren
Namen angesprochen, kann man ausschließlich Informationen darüber erhalten, ob der Optional nil ist oder nicht. Ist der Zustand nicht
nil, muss zunächst ein »Auspacken« stattfinden (Unwrapping in der
englischen Dokumentation), um an den eigentlichen Wert zu gelangen. Das geschieht, indem man dem Bezeichner ein Ausrufezeichen
anhängt, wie es im Listing mit temperatur! geschehen ist.
Jetzt wird aus einem Optional-Double ein regulärer Double-Typ und
in der Entwicklungsumgebung wird der Zahlenwert ohne den Zusatz
Optional angezeigt. Auspacken sollte man einen Optional aber nur,
wenn zuvor sichergestellt wurde, dass die Variable nicht nil ist,
ansonsten führt der Versuch direkt zu einem Fehler. Vergleiche mit
der if-Struktur werden wir uns in den folgenden Kapiteln genauer
ansehen.
Ein anderer Weg, einen Optional auf nil zu testen und auszupacken,
funktioniert über ein Verfahren, das in Swift als Optional-Binding
bezeichnet wird. Dabei wird der Optional in der if-Struktur einer
neuen Konstanten oder Variablen zugewiesen. Ist die Zuweisung
erfolgreich, ist der Wert also nicht nil, erhält man den Wert automatisch in einer regulären Variablen, die aber nur innerhalb der if-Struktur verwendet werden kann.
var temperatur:Double? = 18.2
if let temp = temperatur
{
print(temp)
}
else
{
print("Keine Messung")
}
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
41
Kapitel 1
Datentypen und Optionals
Für Umsteiger ist das Optional-Binding vielleicht etwas gewöhnungsbedürftig, es lohnt sich aber sehr, diese Schreibweise zu verwenden, da
sie zu kurzem und übersichtlichem Code führt. Optionale Typen kommen in Swift bei vielen Klassen und Strukturen zum Einsatz, sodass
wir uns später noch mal mit diesem Thema beschäftigen werden.
42
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
Stichwortverzeichnis
A
advancedBy 62
Alias 134
Anonymer Typ 123
AnyObject 71, 78, 232, 300, 309
Application Kit 15
Array 67, 310
Assoziation 216
Automatic Reference Counting 196, 272
B
Benannte Parameter 116
Bool 36
Boolesche Operatoren 87
break 91, 101
C
catch 266
ceil 34
characters 47
Closed Range 94
Closure 72, 138
Coalescing-Operator 224, 311
Cocoa Framework 15
Cocoa-Touch-Framework 17
compare 48
Completion Handler 141
Connections-Inspector 303
continue 102
Convenience-Initializer 193, 244
count 47, 69
D
Debugger-Ansicht 92
default 91
Designated-Initializer 193, 213
Dictionary 75, 311
dispatch_after 154
dispatch_async 157
distanceTo 60
dropFirst 64
dropLast 64
E
Eigenschaft 174
else if 85
Emoji 61
Enumeration 252, 314
Error-Handling 262
ErrorType 264
Explizite Konvertierung 32
Extensions 237
F
Factory-Methoden 199
Failable-Initializer 194, 221
fallthrough 90
Fast-Enumeration 96
filter 74
first 64
floor 34
for-in-Schleife 93, 96
format 46
Format-Specifier 46, 317
for-Schleife 92
Foundation-Framework 16, 22, 170
Funktionen 111
G
Getter 176
Grand Central Dispatch 154
guard-Struktur 259
Gültigkeitsbereich 106, 322
H
Half-Open Range 94
hasPrefix 82
hasSuffix 81
Human Interface Guidelines 295
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
337
Stichwortverzeichnis
I
IBAction 298
IBOutlet 298
if-Struktur 81
Implizite Konvertierung 31
indices 60
Initializer 323
Inline Result 28, 103, 113, 114
inout 132
Inspector 291
Instanzvariablen 174
Interface Builder 279, 289
internal 173
isEmpty 47, 175
P
Parameter 112
Pattern-Match-Operator 87
print 27, 170
private 173
Project-Navigator 166
Property-Observers 182
Protokolle 227
public 173
Punktnotation 175
K
Q
Kapselung 190
Key-Value-Pair 75
Kommentar 13
Konstanten 28
Kontrollstrukturen 81
Quick Look 28
R
last 64
Laufvariable 92
locale 56, 325
lowercaseString 49, 82
Range 51, 329
rangeOfString 50, 60
Referenzzähler 271
repeat-while-Schleife 99
reverse 97
round 33
Rückgabetyp 119
Rückgabewert 119
M
S
max 35
maxElements 36
Methode 187
min 35
minElements 36
Modulo-Operator 100
MVC-Entwurfsmuster 277
sendAsynchronousRequest 159
sort 72
sortInPlace 72
String 43
stringByTrimmingCharactersInSet 53
String-Dependency 252
String-Interpolation 45, 332
Strukturen 243
Subscript 67
Subscripting 62, 333
substringFromIndex 58
substringToIndex 58
switch-case-Struktur 88
L
N
NSButton 293
NSNumber 57
NSNumberFormatter 55
NSString 43
NSTextField 294, 300
O
Objective-C 272
Optional 37, 54, 75, 218, 260, 327
338
Optional-Binding 41, 51, 109, 327
Optional-Chaining 222, 236, 328
override 209
T
throw 264
Tupel 123, 309
Type-Inference 25, 79, 310, 333
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
Stichwortverzeichnis
U
W
Überladung 114
Unicode 61
uppercaseString 49
Wertepaar 75
while-Schleife 98
Whitespaces 53
Workspace-Fenster 166
V
Variadische Parameter 126
Vererbung 203
viewDidLoad 307
Z
Zirkelverweise 274
Zufallszahlen 284
© des Titels »Einführung in Swift 2« (ISBN 9783958453166) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/316
339