iOS-Apps mit Swift 2 - mitp

Inhaltsverzeichnis
Danksagung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
Einleitung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
An wen richtet sich das Buch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufbau des Buches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Teil I: Grundlagen der Sprache Swift . . . . . . . . . . . . . . . . . . . . . . . . . .
Teil II: iOS-Apps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Swift ist nicht Objective-C Version 3.0 . . . . . . . . . . . . . . . . . . . . . . . . .
Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Stilmittel in den Listings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Frameworks der Apple-Plattformen . . . . . . . . . . . . . . . . . . . . . . . .
Die Installation von Xcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Entwickler-Community von Apple . . . . . . . . . . . . . . . . . . . . . . . . .
Webseite und Downloads zum Buch. . . . . . . . . . . . . . . . . . . . . . . . . . .
15
15
16
16
18
21
23
24
24
26
28
28
Teil I
Grundlagen der Sprache Swift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
31
31
33
38
41
42
43
44
46
2
2.1
2.2
2.3
2.4
Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
String Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zeichenketten vergleichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Textabschnitte finden und ersetzen . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zeichenketten in Zahlentypen konvertieren . . . . . . . . . . . . . . . . . . . .
49
50
52
54
57
5
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Inhaltsverzeichnis
2.5
2.6
2.7
2.8
Die Klasse NSNumber. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Texte teilen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Subscripting mit Unicode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Anfang und Ende von Zeichenketten. . . . . . . . . . . . . . . . . . . . . . . . . .
60
61
63
65
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
73
77
4
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
Fallunterscheidungen und Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . .
Die if-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die switch-case-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die for-Schleife. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Schleifen und Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückwärts durch die for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Schleifen mit Fallunterscheidungen . . . . . . . . . . . . . . . . . . . . . . . . . .
Werte als Diagramme anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gültigkeitsbereiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
79
79
85
88
90
91
93
94
97
99
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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
103
103
107
109
111
114
117
119
121
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 . . . . . . . . . . . . . . .
125
125
127
131
135
138
141
143
6
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Inhaltsverzeichnis
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
147
147
150
153
155
156
157
161
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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
167
169
172
174
175
177
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 Coalescin Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
181
181
184
185
187
191
195
198
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
199
199
202
204
207
209
11
11.1
11.2
11.3
11.4
11.5
11.6
Strukturen und Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zurück zum Spielplatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Strukturen oder Klassen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
String Dependencies – Abhängigkeiten von Zeichenketten . . . . . . .
Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verschachtelte Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Enumerationen mit Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
213
213
217
219
220
223
224
7
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Inhaltsverzeichnis
11.7
11.8
Enumerationen mit begleitenden Werten . . . . . . . . . . . . . . . . . . . . . .
Binärzahlen und OptionSetType-Strukturen. . . . . . . . . . . . . . . . . . . .
226
228
12
12.1
12.2
12.3
12.4
12.5
Sicherer Programmcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Funktionen absichern mit guard . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
defer-Blöcke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fehler werfen mit throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fehler auffangen mit catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
235
235
237
239
241
242
13
13.1
13.2
13.3
Speicherverwaltung mit Referenzzähler . . . . . . . . . . . . . . . . . . . . . . .
Automatic Reference Counting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Starke und schwache Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zirkelverweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
245
247
248
249
14
14.1
14.2
14.3
14.4
14.5
14.6
14.7
14.8
Robuste Anwendungen und automatisierte Tests . . . . . . . . . . . . . . .
Markup-Kommentare im Playground . . . . . . . . . . . . . . . . . . . . . . . . .
Kommentare in Projekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Kommentare für die Jumpbar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Assertions – Die Behauptungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Kompilieren als Debug oder Release . . . . . . . . . . . . . . . . . . . . . . . . . .
Präprozessor-Makros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Automatisiertes Testen mit Xcode . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tests für eigene Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
251
251
254
257
258
261
264
266
269
Teil II iOS-Apps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
275
15
15.1
15.2
15.3
15.4
15.5
15.6
15.7
15.8
15.9
277
277
279
282
288
289
291
295
298
302
Lotto – 6 aus 49 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
MVC: Model View Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der iOS-Simulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Lottozahlengenerator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Inspector und Bibliothek. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Arbeiten mit dem Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zurück zum Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das war es jetzt schon? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Inhaltsverzeichnis
16
16.1
16.2
16.3
16.4
16.5
16.6
16.7
Ein Blick hinter die Kulissen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Was verbirgt sich hinter IBAction und IBOutlet? . . . . . . . . . . . . . . . .
Ein View wird geladen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programmstart einer iOS-Anwendung . . . . . . . . . . . . . . . . . . . . . . . .
Instanzen erzeugen mit Lazy Loading . . . . . . . . . . . . . . . . . . . . . . . . .
Alles dreht sich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Erste Schritte mit Autolayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein Icon für die App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
305
305
307
309
314
315
317
324
17
17.1
17.2
17.3
17.4
17.5
17.6
17.7
Eingaben mit virtuellen Tastaturen . . . . . . . . . . . . . . . . . . . . . . . . . . .
Einsatz für Autolayout. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Auftritt für den Assistenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tastaturen ein- und ausblenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der First Responder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Navigation zwischen Eingabefeldern . . . . . . . . . . . . . . . . . . . . . . . . . .
Aus dem View in das Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mitteilungen mit dem UIAlertView . . . . . . . . . . . . . . . . . . . . . . . . . . .
329
331
333
338
341
343
345
347
18
18.1
18.2
18.3
18.4
18.5
Schieberegler, Textformatierungen und unendliche Werte . . . . . . . .
Der Schieberegler – UISlider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Daten-Model: ConsumptionCalculator . . . . . . . . . . . . . . . . . . . . . . . .
Methodenaufrufe mit Absender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Statische und dynamische Textformatierungen . . . . . . . . . . . . . . . . .
Ungültige Werte erkennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
351
352
356
359
363
366
19
19.1
19.2
19.3
19.4
19.5
19.6
19.7
Storyboards – Mit dem Drehbuch durch die App . . . . . . . . . . . . . . . .
Ein einfaches Storyboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Segue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Lebenszyklus einer Szene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Storyboards mit Datenübergabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Detailansicht und Navigation Controller . . . . . . . . . . . . . . . . . . . . . . .
Vorbereitungen für den Übergang. . . . . . . . . . . . . . . . . . . . . . . . . . . .
Daten für die View Controller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
371
371
375
379
381
387
391
393
20
20.1
20.2
20.3
Storyboards mit Protokollen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein Protokoll für den View Controller . . . . . . . . . . . . . . . . . . . . . . . . .
Das UIApplicationDelegate-Protokoll . . . . . . . . . . . . . . . . . . . . . . . . .
Eine Szene für das Jahr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
399
400
403
404
9
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Inhaltsverzeichnis
20.4
20.5
Verpflichtungen für den View Controller . . . . . . . . . . . . . . . . . . . . . .
Kommunikation in alle Richtungen . . . . . . . . . . . . . . . . . . . . . . . . . . .
408
413
21
21.1
21.2
21.3
21.4
21.5
Navigation mit einem Tableisten-Controller . . . . . . . . . . . . . . . . . . . .
Der Tableisten-Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Konfiguration der Schaltflächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ausflug in die Delegation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein Delegate für den Tableisten-Controller . . . . . . . . . . . . . . . . . . . . .
Delegation – meine Nachrichten an dich. . . . . . . . . . . . . . . . . . . . . . .
415
416
419
423
424
427
22
22.1
22.2
22.3
22.4
22.5
Grafische Oberflächen ohne Interface Builder . . . . . . . . . . . . . . . . . .
Kontrolle ist gut – eine Checkliste ist besser! . . . . . . . . . . . . . . . . . . .
Steuerelemente erstellen mit Swift-Anweisungen . . . . . . . . . . . . . . .
Nachrichten mit Target-Action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tags – Etiketten für Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Suchen im Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
433
434
438
444
447
448
23
23.1
23.2
23.3
23.4
23.5
23.6
23.7
Serialisierung – Aus dem Speicher in eine Datei . . . . . . . . . . . . . . . .
Ein Dictionary für das Repository. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Objekte sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Alles nicht ganz so einfach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Sandbox – Apps im Sandkasten. . . . . . . . . . . . . . . . . . . . . . . . . . .
Das NSCoding-Protokoll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Serialisierung – Jetzt wird gespeichert! . . . . . . . . . . . . . . . . . . . . . . . .
Die Nachrichtenzentrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
455
455
458
460
463
464
466
472
24
24.1
24.2
24.3
24.4
24.5
24.6
24.7
Der Picker – ein ganz besonderes Steuerelement. . . . . . . . . . . . . . . .
Eine neue Klasse für Farben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das Picker-Steuerelement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Protokolle für den Picker. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Kommunikation mit einem Picker. . . . . . . . . . . . . . . . . . . . . . . . . . . .
Eine Farbmischer-App. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Picker-Einstellungen auslesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Von Dezimal zu Hexadezimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
477
478
482
484
487
489
492
493
25
25.1
25.2
25.3
25.4
Tabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Showroom-App – der digitale Ausstellungsraum . . . . . . . . . . . .
Wohin mit dem Daten-Model? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Konfigurationen im Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . .
Der Tabellen-View-Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
497
498
501
502
506
10
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Inhaltsverzeichnis
25.5
25.6
25.7
25.8
Zweite Szene: Die Detailansicht. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein neuer Segue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vorsicht, Fehlerquelle! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Bilder anzeigen mit dem UIImageView . . . . . . . . . . . . . . . . . . . . . . .
510
513
517
518
26
26.1
26.2
26.3
26.4
26.5
26.6
26.7
Eye Candy – Unsere App soll schöner werden . . . . . . . . . . . . . . . . . .
Angepasste Tabellenzellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein Controller für die Tabellenzelle . . . . . . . . . . . . . . . . . . . . . . . . . . .
Abgerundete Ecken und Rahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Settings – die Einstellungen einer App . . . . . . . . . . . . . . . . . . . . . . . .
NSUserDefaults – die Benutzereinstellungen . . . . . . . . . . . . . . . . . .
Standardeinstellungen erforderlich . . . . . . . . . . . . . . . . . . . . . . . . . . .
Kommunikation mit der Nachrichtenzentrale . . . . . . . . . . . . . . . . . .
525
529
533
536
539
544
546
548
27
27.1
27.2
27.3
27.4
27.5
27.6
Der Collection View. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Storyboard mit Collection View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Collection View Controller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mit dem Segue zur Detailansicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Teilen mit dem UIActivityViewController. . . . . . . . . . . . . . . . . . . . . .
Drucken mit AirPrint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Unterschiedliche Texte für unterschiedliche Dienste. . . . . . . . . . . . .
553
553
557
563
566
570
572
28
28.1
28.2
28.3
28.4
28.5
28.6
28.7
28.8
Zeichnen mit Core Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Klasse UIView. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rechtecke zeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Frame und Bounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Farbige Formen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Speichern der Context-Einstellungen. . . . . . . . . . . . . . . . . . . . . . . . . .
Zeichnen von Farbverläufen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Arbeiten mit Beschneidungspfaden. . . . . . . . . . . . . . . . . . . . . . . . . . .
Kurven und Figuren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
577
577
581
585
590
593
596
599
603
29
29.1
29.2
29.3
29.4
29.5
29.6
29.7
Multi-Touch mit Gestenerkennung . . . . . . . . . . . . . . . . . . . . . . . . . . .
Linien zeichnen einen Pfeil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Einfache Berührungserkennung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Wischgesten erkennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Objekte bewegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Pinch to Zoom – Vergrößern mit zwei Fingern . . . . . . . . . . . . . . . . .
Verschiedene Gesten gleichzeitig erkennen . . . . . . . . . . . . . . . . . . . .
Objekte drehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
609
609
611
613
614
618
622
624
11
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Inhaltsverzeichnis
29.8
29.9
Gesten im Konflikt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Schüttelgeste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
626
628
30
30.1
30.2
30.3
30.4
30.5
30.6
Digitale und analoge Uhren mit Timern . . . . . . . . . . . . . . . . . . . . . . .
Die Klasse NSTimer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Wie spät ist es? – Datum und Uhrzeit ermitteln . . . . . . . . . . . . . . . .
Extensions für die Klasse NSTimer . . . . . . . . . . . . . . . . . . . . . . . . . . .
Eine analoge Uhr mit Core Graphics . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein Zifferblatt zeichnen mit Winkelfunktionen . . . . . . . . . . . . . . . . .
Timer im Einsatz – die Uhr tickt . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
631
631
635
636
641
645
647
31
31.1
31.2
31.3
31.4
Lokale Benachrichtigungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lokale Benachrichtigungen mit UILocalNotification . . . . . . . . . . . . .
Eingehende Nachrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Benachrichtigungen anpassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Push-Benachrichtigungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
651
652
656
659
661
32
32.1
32.2
32.3
32.4
32.5
32.6
Karten und Koordinaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Location-Manager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Auswerten von Positionsinformationen. . . . . . . . . . . . . . . . . . . . . . . .
Geocoding – Wo bin ich hier?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Karten mit dem MKMapView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Annotations – Anmerkungen auf der Karte . . . . . . . . . . . . . . . . . . . .
Benutzerdefinierte Anmerkungen gestalten und anzeigen . . . . . . . .
663
664
666
669
672
678
681
33
33.1
33.2
33.3
33.4
33.5
33.6
33.7
33.8
Daten suchen und finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zugriff mit Key Value Coding. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Schlüsselpfade und Aggregatfunktionen . . . . . . . . . . . . . . . . . . . . . . .
Listen filtern mit NSPredicate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Erweiterte Vergleiche, logische Operatoren und Closures . . . . . . . . .
Prädikate mit regulären Ausdrücken . . . . . . . . . . . . . . . . . . . . . . . . . .
Daten filtern für Tabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Listen für den Tabellen-View-Controller . . . . . . . . . . . . . . . . . . . . . . .
Suchen mit dem UISearchController. . . . . . . . . . . . . . . . . . . . . . . . . .
685
685
688
692
695
697
698
703
706
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
715
12
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
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 bei 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-Xcode-Fenster aus
erstellen, das 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...
Ein Playground der Plattform iOS unterscheidet sich von einem OS-X-Spielplatz
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 sie später leicht wiederfinden. Sie sollten immer
31
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Kapitel 1
Datentypen und Optionals
bemüht sein, Ihre Projekte gut zu organisieren, um die Übersicht nicht zu verlieren und Dinge schnell finden zu können.
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-
32
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
1.2
Variablen und Konstanten
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 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 Playground-Fensters 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.
33
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Kapitel 1
Datentypen und Optionals
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 sogenannter Integer. Bei taxRate finden wir Nachkommastellen,
sodass es sich um eine Dezimalzahl handeln muss. Dort sollte dann der Typ
Double oder Float verwendet werden, denn als ganze Zahl ließe sich dieser Wert
nur unvollständig ablegen.
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
34
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
1.2
Variablen und Konstanten
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
in Ihrem Playground 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.
35
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Kapitel 1
Datentypen und Optionals
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 Datenwort 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-Bit-Datenwort, 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 nicht neben den
36
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
1.2
Variablen und Konstanten
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, das 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 Anwendung 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 betragen.
In Swift werden Konstanten über den Befehl let erzeugt. Das nachfolgende Listing zeigt die Definition der Zahl Pi sowie einer Serveradresse als Zeichenkette.
37
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Kapitel 1
Datentypen und Optionals
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.0
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.
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
38
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
1.3
Zahlendatentypen konvertieren
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:
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 Double-Typ 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
manchen 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
39
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Kapitel 1
Datentypen und Optionals
verlassen muss, ist in Swift eine implizite Konvertierung nicht möglich. Die
gezeigte Fehlermeldung ist die Folge.
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 Int-Funktion 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 Umwandlung, 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
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
40
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
1.4
Werte runden
// 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 abzuschneiden, 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
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)
41
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Kapitel 1
Datentypen und Optionals
// 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!
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
42
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
1.6
Der Datentyp Bool
// Double-Typen ermitteln
var maximum = max(m1,m2,m3,m4)
var minimum = min(m1,m2,m3,m4)
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 boolescher 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
43
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Kapitel 1
Datentypen und Optionals
entspricht. Weil so die Lesbarkeit des Codes aber sehr beeinträchtigt wird, gibt es
diese Möglichkeit in Swift 2.0 nicht mehr. Die aus Objective-C bekannten Werte
YES und NO funktionieren in Swift ebenfalls nicht.
// Alternative Zuweisung von Zahlen
// Funktioniert in Swift 2.0 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 eben dies 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?
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öglichen 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 vor-
44
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
1.7
Optionals
liegt, 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 Variablen 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 Xcode-Version 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
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)
45
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Kapitel 1
Datentypen und Optionals
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)
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.
1.8
Programmieren mit Optionals
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.
46
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
1.8
Programmieren mit Optionals
var temperatur:Double? = 18.2
if temperatur == nil
{
print("Keine Messung")
}
else
{
print(temperatur!)
}
Vereinfacht beschrieben, hat man es bei einem Optional immer mit zwei Werten
zu tun. Wird eine Variable oder Konstante mit ihrem 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 ifStruktur verwendet werden kann.
var temperatur:Double? = 18.2
if let temp = temperatur
{
print(temp)
}
else
{
print("Keine Messung")
}
47
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
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.
48
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Stichwortverzeichnis
Symbole
#define 306
A
Activity Item 567
Adresse
ermitteln 669
advancedBy 64
Aggregatfunktion 692
AirPrint 570
Alias 121
Analoge Uhr
mit Zeigern 641
Animierter Übergang 428
Annotation 678
Anonymer Typ 112
AnyObject 70, 76, 202, 297, 359, 637
Application Kit 24
Argumente 103
Array 67
as-Anweisung 392
Assertion 260
Assistant Editor 354
Assistent 333
Associated Values 227
Assoziation 191
Ausgabebereich 32
Ausrichtung
verhindern 565
Autolayout 317, 331
Automatic Reference Counting 174, 247
B
Badge 659
Bar Button Item 396, 405
Benachrichtigung 652
Benannter Parameter 104, 107
Beobachter-Entwurfsmuster 475
Berechnete Eigenschaft 157
Berührungserkennung 611
Beschneidungspfad 599
Bézierkurve 603
Bilddatei
hinzufügen 521
Binärzahl 230
Bit 230
Bitmuster 230
Bool 43
Boolescher Operator 83, 84
break 87, 95
Bundle 657
Button 291
C
catch 242
ceil 41
CGColor 582
CGFloat 495, 560
CGPoint 439
CGRect 439
CGRectMake 439, 579, 583, 644
CGSize 439
characters 52
Checkbox 440
CLGeocoder 669
Clipping Path 599
CLLocationManager 664
Closed Range 89
Closure 71, 126, 459, 637, 669, 696
Coalescing Operator 198
Cocoa Framework 24
Cocoa Touch Framework 26
Collection View 553
Combobox 478
compare 53
Completion Handler 128
Constraints 317
aktualisieren 390
automatisch anpassen 321
continue 96
Controller 295
Convenience Initializer 191, 214, 479, 493
Core Graphics 577, 642
Core Location 663
count 52, 69
D
Dateinamen
anhängen 467
715
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Stichwortverzeichnis
Datum
ermitteln 635
Debugger-Ansicht 88
Debug-Version 261
default 87
deinit 174, 380, 634
Delegate 403, 423
Delegation 423
Designated Initializer 172, 189, 192, 380, 479
Dezimaltrennzeichen 363
Dictionary 73, 284, 456, 660
dispatch_after 139
dispatch_async 141
distanceTo 62
Double Tap 626
dropFirst 66
dropLast 66
Drucken 571
E
Eigenschaft 156
berechnete 157
Eingabefeld 329
Ellipse 592
Ellipsis Operator 115
else if 82
E-Mail 567
Emoji 63
Enumeration 220
Erinnerung 652
Error-Handling 239
ErrorType 241
Explizite Konvertierung 40
Extension 207, 637
External Parameter Name 108
F
Facebook 567
Factory-Methode 176
Failable Initializer 172, 195
fallthrough 86
Farben 482
Farbmischer 489
Farbverlauf 596
Fast Enumeration 91
filter 73
Filtern 692
first 65
First Responder 341
floor 41
fmin 643
for-in-Schleife 89, 91
format 51
Format Specifier 51, 360, 494, 635
for-Schleife 88, 286, 645, 702
Forward Geocoding 670
Foundation Framework 25, 31, 153
Frame 439
Funktion 103
G
Geocoding 669
Gestenerkennung 609
Getter 158, 177
GPS-Sensor 665
Grafik
für Retina-Display 421
Grand Central Dispatch 138
Groß- und Kleinschreibung 53, 71, 80
guard-Struktur 235
Gültigkeitsbereich 99
H
Half-Open Range 89
hasPrefix 80
hasSuffix 79
Human Interface Guidelines 293
I
IBAction 295, 305
erstellen 336
IBOutlet 295, 305
erstellen 335
Icon 324
if-Struktur 79
Implizite Konvertierung 39
Indexpositionen 113
indices 62
Info.plist 663, 708
init 170
Inline Closure 135
Inline Result 37, 97, 104, 105
inout 120
Inspector 289
Instanziierung 155
Instanzvariable 156
Interface Builder 288
internal 155
iOS-Simulator 280
Ausrichtung 316
Home-Button 281
Koordinaten eingeben 668
isEmpty 52, 157
isKindOfClass 614
Iteration 91
J
Jumpbar 257, 336, 533
716
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Stichwortverzeichnis
K
Kapselung 169, 404, 501, 685
Karte 663
Callout 682
eigenen Ort anzeigen 672
Maßstab 676
Stecknadel 681
kCFBundleNameKey 657
Key Path 688
Key Value Coding 685, 686
Key Value Pair 74
Klasse 155
anlegen 153
Klassenmethode 639
Kombinationslistenfeld 478
Kommentar 23, 251
In Jumpbar 257
Konstante 37, 75
Konstanten als Parameter 119
Kontrollstruktur 79
Konvertierung
explizite 40
implizite 39
Koordinatensystem 583
L
last 65
Laufvariable 88
Launch Screen 325
Layer 537
Lazy Loading 315
locale 59
Lottozahlengenerator 282
lowercaseString 54, 80
M
Makro 310
Map Kit 663
map-Methode 130
Markdown 253
Markup-Ansicht 253
Master-Detail-Beziehung 497, 510
max 42
maxElements 43
Mehrfachvererbung 191
Methode 167
Methodenaufruf 445
min 42
minElements 43
Mitteilungszentrale 655
MKAnnotationView 679, 681
MKCoordinateSpanMake 676
MKMapView 672, 679
MKPointAnnotation 678
Modulo Operator 94, 525
MVC-Entwurfsmuster 277
N
Nachrichtenzentrale 473
Named Parameter 108
Navigation Controller 381
Navigation Item 391
Navigationsleiste 390
NSCalendar 647
NSCoding 464
NSDate 635, 647
NSDateFormatter 635
NSFileManager 469
NSFormatter 667
NSKeyedArchiver 464
NSLocale 635
NSNotificationCenter 473, 548
NSNumber 60
NSNumberFormatter 58, 491
NSObject 465, 686
NSPredicate 693
NSString 49
NSTimer 631, 632
NSURL 467
NSUserDefaults 544
O
Objective-C 49, 154, 174, 247, 305
Objekt 155
bewegen 614
identifizieren 447
Observer 474
Observer Pattern 475
Optional 44, 58, 74, 193, 235, 409
Optional Binding 47, 55, 102
Optional Chaining 196, 206
OptionSetType 231
Outline View 294, 323, 353, 375, 420
override 186, 315, 380, 465
P
Painter Model 583
Pan 614
Parameter 103
benannter 104, 107
variadischer 115
Parameter Ellipsis 115
Pattern-Match Operator 84
Picker 478
Picker-Steuerelement 478
Pinch to Zoom 609, 618
717
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Stichwortverzeichnis
Playground 31
Position des Geräts
ermitteln 663
Prädikat 692
Präprozessor-Makro 264
print 36, 153
Printer Simulator 570
private 155, 168
Project-Navigator 150
Property List 540
Property List Editor 540
Property Observer 163
Protokoll 199, 400
Prototype Cell 505, 508
public 155
Punktnotation 157
Punktnotations-Syntax 686
Push-Benachrichtigung 661
Q
Quartz 2D 577
Quick Look 37
R
Range 55
rangeOfString 55, 62
Read-Eval-Print Loop (REPL) 66
Rechteck
mit abgerundeten Ecken 536
zeichnen 581
Refactoring 373
Referenzzähler 246
Regular Expressions 697
Regulärer Ausdruck 697
Relationship Segue 418
Release Build 261
repeat-while-Schleife 94
Repository 435, 463, 499, 559, 699
Results Sidebar 36
Retina-Display 521
reverse 92
Reverse Geocoding 669
Richtlinien 663
round 41
Rückgabetyp 110
Rückgabewert 110
RunLoop 636
S
Schieberegler 352
Schlüssel 74
Schlüsselpfad 688
Schriftart 531
Schriftgröße 531
Schüttelgeste 628
Schwenk 614
Scope 99
Segue 375, 405, 417, 513
anlegen 376
Sektion 506
Selektor 633
Semikolon 33
sendAsynchronousRequest 143
Serialisierung 455
setNeedsDisplay 649
Setter 159, 177
Settings Bundle 539, 547
sort 72
sortInPlace 71
Speicheradresse
vergleichen 431
Speicherzeiger 49
Steuerelement
erzeugen 439
Storyboard 371, 378, 415
erweitern 371
in Navigation einbetten 390
mit Datenübergabe 381
String 49
String Dependency 220, 517, 688
String Interpolation 50
stringByTrimmingCharactersInSet 57
Struktur 213
Subscript 67
Subscripting 63
substringFromIndex 61
substringToIndex 61
Suchen 706
Suchleiste 706
Swipe 615
switch-case-Struktur 85
Symbol
für Schaltfläche 420
Szene 372
ausblenden 410
verlassen 379
T
Tabellenzelle 503
Table View Cell 503
Tableiste 416
Tableisten-Controller 417
Tag 447
Tap 615
Target-Action-Entwurfsmuster 445, 612
718
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221
Stichwortverzeichnis
Tastatur 338
ausblenden 341
auswählen 338
virtuelle 329
Text
veröffentlichen 573
Texte verketten 50
throw 241
Timer 631
Tupel 112
Twitter 567
Typ
anonymer 112
Type Inference 35, 77
typealias 637
UISwitch 471
UITableView 498, 503, 698
UITableViewCell 503, 529, 533
UITableViewController 503, 703
UITableViewDataSource 510
UITableViewDelegate 510
UITapGestureRecognizer 612
UITextField 329
UIView 577
UIViewAnimationTransition 429
UIViewController 295, 308, 417
Unicode 63
Unit-Tests 268
uppercaseString 54
V
U
Übergang
animierter 428
Überladung 105
Uhr
analoge 641
Uhrzeiger 647
Uhrzeit 631
ermitteln 635
UIActivityViewController 566
UIAlertView 347
UIApplication 424, 472
UIApplicationDelegate 403
UIButton 291
UICollectionView 553
UICollectionViewCell 553
UICollectionViewController 558
UIColor 478, 489, 493, 582
UIControl 340
UIControlState 385
UIEdgeInsets 560
UIGestureRecognizer 609
UIImageView 518, 529, 534, 562
UIKit Framework 277
UILabel 292, 307, 442
UILocalNotification 652
UINavigationController 395, 565
UINavigationItem 523
UIPanGestureRecognizer 614
UIPickerView 482, 489
UIPickerViewDataSource 484
UIPinchGestureRecognizer 619
UIRotationGestureRecognizer 624
UISearchController 706
UISlider 352, 404
UIStoryboardSegue 392
UISwipeGestureRecognizer 613
Variable 33
Variablenname 34
Variadischer Parameter 115
Vererbung 181
viewDidAppear 379
viewDidLoad 307, 379
viewWillAppear 379
Virtuelle Tastatur 329
W
weak 394
Weiterleiten
Informationen 566
Wertepaar 74
while-Schleife 93
Whitespace 56
Winkelfunktion 645
Wischgeste 613
Workspace-Fenster 150
Wörterbücher 73
X
XCTAssertNotNil 269
XCTFail 268
Z
Zahlentypen umwandeln 50, 57
Zeichenketten
teilen 61
vergleichen 52
Zellen
einfärben 525
Höhe 525
Zifferblatt 645
Zirkelverweis 249
Zufallszahl 284
719
© des Titels »iOS-Apps mit Swift 2« (ISBN 9783958452213) 2016 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/221