iOS-Apps mit Swift 21).pdf · Inhaltsverzeichnis 11 25.5 Zweite Szene: Die Detailansicht. . . . . ....

5

Inhaltsverzeichnis

Danksagung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15An wen richtet sich das Buch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

Aufbau des Buches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Teil I: Grundlagen der Sprache Swift . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Teil II: iOS-Apps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

Swift ist nicht Objective-C Version 3.0 . . . . . . . . . . . . . . . . . . . . . . . . . 21

Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Stilmittel in den Listings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

Die Frameworks der Apple-Plattformen . . . . . . . . . . . . . . . . . . . . . . . . 24

Die Installation von Xcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Die Entwickler-Community von Apple . . . . . . . . . . . . . . . . . . . . . . . . . 28

Webseite und Downloads zum Buch. . . . . . . . . . . . . . . . . . . . . . . . . . . 28

Teil I Grundlagen der Sprache Swift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

1 Datentypen und Optionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311.1 Willkommen auf dem Spielplatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311.2 Variablen und Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331.3 Zahlendatentypen konvertieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381.4 Werte runden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411.5 Minimum und Maximum. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421.6 Der Datentyp Bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431.7 Optionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441.8 Programmieren mit Optionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

2 Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492.1 String Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502.2 Zeichenketten vergleichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522.3 Textabschnitte finden und ersetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . 542.4 Zeichenketten in Zahlentypen konvertieren . . . . . . . . . . . . . . . . . . . . 57

© 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

6

2.5 Die Klasse NSNumber. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602.6 Texte teilen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612.7 Subscripting mit Unicode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632.8 Anfang und Ende von Zeichenketten. . . . . . . . . . . . . . . . . . . . . . . . . . 65

3 Arrays und Dictionaries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673.1 Arrays – Listen von Elementen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673.2 Arrays sortieren und filtern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 713.3 Dictionaries, die schnellen Wörterbücher . . . . . . . . . . . . . . . . . . . . . . 733.4 Arrays aus Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

4 Fallunterscheidungen und Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . 794.1 Die if-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 794.2 Die switch-case-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 854.3 Die for-Schleife. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 884.4 Schleifen und Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 904.5 Rückwärts durch die for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 914.6 Die while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 934.7 Schleifen mit Fallunterscheidungen . . . . . . . . . . . . . . . . . . . . . . . . . . 944.8 Werte als Diagramme anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 974.9 Gültigkeitsbereiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

5 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1035.1 Die erste Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1035.2 Benannte Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1075.3 Funktionen mit Rückgabewert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1095.4 Tupel und anonyme Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1115.5 Eine unbestimmte Anzahl von Parametern. . . . . . . . . . . . . . . . . . . . . 1145.6 Funktionen mit Standardwerten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175.7 Parameter sind unveränderlich. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1195.8 Aliasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

6 Closures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1256.1 Closures sind Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1256.2 Closures als Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1276.3 Arrays sortieren mit Closures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1316.4 Variablen einfangen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1356.5 Asynchrone Closures mit Grand Central Dispatch . . . . . . . . . . . . . . . 1386.6 Parallele Verarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1416.7 Asynchrone Aufrufe mittels Completion-Handler . . . . . . . . . . . . . . . 143


Inhaltsverzeichnis

7

7 Klassen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1477.1 Das erste Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1477.2 Erste Schritte im Workspace-Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . 1507.3 Die Klasse Person . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1537.4 Von der Klasse zum Objekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1557.5 Eigenschaften und Punktnotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1567.6 Berechnete Eigenschaften mit Getter und Setter . . . . . . . . . . . . . . . . 1577.7 Eigenschaften beobachten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

8 Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1678.1 Methoden zur Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1698.2 Failable Initializers – Wenn es mal schiefgeht . . . . . . . . . . . . . . . . . . 1728.3 Methoden zu Deinitialisierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1748.4 Klassenmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1758.5 Methoden kontra Eigenschaften. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

9 Vererbung und Assoziationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1819.1 Das Erbe der Klasse Person . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1819.2 Erweiterungen der abgeleiteten Klasse . . . . . . . . . . . . . . . . . . . . . . . . 1849.3 Methoden überschreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1859.4 Die Initialisierung abgeleiteter Klassen . . . . . . . . . . . . . . . . . . . . . . . . 1879.5 Assoziationen – Beziehungen zwischen Objekten . . . . . . . . . . . . . . . 1919.6 Optional Chaining . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1959.7 Der Coalescin Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198

10 Protokolle und Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19910.1 Ein eigenes Protokoll entwickeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19910.2 Protokolle statt Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20210.3 Optionale Protokolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20410.4 Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20710.5 Extensions mit Protokollen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

11 Strukturen und Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21311.1 Zurück zum Spielplatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21311.2 Strukturen oder Klassen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21711.3 String Dependencies – Abhängigkeiten von Zeichenketten . . . . . . . 21911.4 Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22011.5 Verschachtelte Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22311.6 Enumerationen mit Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224


Inhaltsverzeichnis

8

11.7 Enumerationen mit begleitenden Werten . . . . . . . . . . . . . . . . . . . . . . 22611.8 Binärzahlen und OptionSetType-Strukturen . . . . . . . . . . . . . . . . . . . . 228

12 Sicherer Programmcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23512.1 Funktionen absichern mit guard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23512.2 defer-Blöcke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23712.3 Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23912.4 Fehler werfen mit throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24112.5 Fehler auffangen mit catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

13 Speicherverwaltung mit Referenzzähler . . . . . . . . . . . . . . . . . . . . . . . 24513.1 Automatic Reference Counting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24713.2 Starke und schwache Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24813.3 Zirkelverweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

14 Robuste Anwendungen und automatisierte Tests . . . . . . . . . . . . . . . 25114.1 Markup-Kommentare im Playground . . . . . . . . . . . . . . . . . . . . . . . . . 25114.2 Kommentare in Projekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25414.3 Kommentare für die Jumpbar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25714.4 Assertions – Die Behauptungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25814.5 Kompilieren als Debug oder Release . . . . . . . . . . . . . . . . . . . . . . . . . . 26114.6 Präprozessor-Makros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26414.7 Automatisiertes Testen mit Xcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26614.8 Tests für eigene Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269

Teil II iOS-Apps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

15 Lotto – 6 aus 49 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27715.1 MVC: Model View Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27715.2 Der iOS-Simulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27915.3 Der Lottozahlengenerator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28215.4 Der Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28815.5 Inspector und Bibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28915.6 Arbeiten mit dem Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . 29115.7 Der Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29515.8 Zurück zum Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29815.9 Das war es jetzt schon? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302


Inhaltsverzeichnis

9

16 Ein Blick hinter die Kulissen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30516.1 Was verbirgt sich hinter IBAction und IBOutlet? . . . . . . . . . . . . . . . . 30516.2 Ein View wird geladen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30716.3 Programmstart einer iOS-Anwendung . . . . . . . . . . . . . . . . . . . . . . . . 30916.4 Instanzen erzeugen mit Lazy Loading . . . . . . . . . . . . . . . . . . . . . . . . . 31416.5 Alles dreht sich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31516.6 Erste Schritte mit Autolayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31716.7 Ein Icon für die App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

17 Eingaben mit virtuellen Tastaturen . . . . . . . . . . . . . . . . . . . . . . . . . . . 32917.1 Einsatz für Autolayout. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33117.2 Auftritt für den Assistenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33317.3 Tastaturen ein- und ausblenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33817.4 Der First Responder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34117.5 Navigation zwischen Eingabefeldern . . . . . . . . . . . . . . . . . . . . . . . . . . 34317.6 Aus dem View in das Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34517.7 Mitteilungen mit dem UIAlertView . . . . . . . . . . . . . . . . . . . . . . . . . . . 347

18 Schieberegler, Textformatierungen und unendliche Werte . . . . . . . . 35118.1 Der Schieberegler – UISlider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35218.2 Daten-Model: ConsumptionCalculator . . . . . . . . . . . . . . . . . . . . . . . . 35618.3 Methodenaufrufe mit Absender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35918.4 Statische und dynamische Textformatierungen . . . . . . . . . . . . . . . . . 36318.5 Ungültige Werte erkennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366

19 Storyboards – Mit dem Drehbuch durch die App . . . . . . . . . . . . . . . . 37119.1 Ein einfaches Storyboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37119.2 Segue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37519.3 Der Lebenszyklus einer Szene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37919.4 Storyboards mit Datenübergabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38119.5 Detailansicht und Navigation Controller . . . . . . . . . . . . . . . . . . . . . . . 38719.6 Vorbereitungen für den Übergang . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39119.7 Daten für die View Controller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393

20 Storyboards mit Protokollen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39920.1 Ein Protokoll für den View Controller . . . . . . . . . . . . . . . . . . . . . . . . . 40020.2 Das UIApplicationDelegate-Protokoll . . . . . . . . . . . . . . . . . . . . . . . . . 40320.3 Eine Szene für das Jahr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404


Inhaltsverzeichnis

10

20.4 Verpflichtungen für den View Controller . . . . . . . . . . . . . . . . . . . . . . 40820.5 Kommunikation in alle Richtungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 413

21 Navigation mit einem Tableisten-Controller . . . . . . . . . . . . . . . . . . . . 41521.1 Der Tableisten-Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41621.2 Konfiguration der Schaltflächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41921.3 Ausflug in die Delegation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42321.4 Ein Delegate für den Tableisten-Controller . . . . . . . . . . . . . . . . . . . . . 42421.5 Delegation – meine Nachrichten an dich. . . . . . . . . . . . . . . . . . . . . . . 427

22 Grafische Oberflächen ohne Interface Builder . . . . . . . . . . . . . . . . . . 43322.1 Kontrolle ist gut – eine Checkliste ist besser! . . . . . . . . . . . . . . . . . . . 43422.2 Steuerelemente erstellen mit Swift-Anweisungen . . . . . . . . . . . . . . . 43822.3 Nachrichten mit Target-Action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44422.4 Tags – Etiketten für Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44722.5 Suchen im Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448

23 Serialisierung – Aus dem Speicher in eine Datei . . . . . . . . . . . . . . . . 45523.1 Ein Dictionary für das Repository . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45523.2 Objekte sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45823.3 Alles nicht ganz so einfach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46023.4 Die Sandbox – Apps im Sandkasten. . . . . . . . . . . . . . . . . . . . . . . . . . . 46323.5 Das NSCoding-Protokoll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46423.6 Serialisierung – Jetzt wird gespeichert! . . . . . . . . . . . . . . . . . . . . . . . . 46623.7 Die Nachrichtenzentrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472

24 Der Picker – ein ganz besonderes Steuerelement . . . . . . . . . . . . . . . . 47724.1 Eine neue Klasse für Farben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47824.2 Das Picker-Steuerelement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48224.3 Protokolle für den Picker. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48424.4 Kommunikation mit einem Picker. . . . . . . . . . . . . . . . . . . . . . . . . . . . 48724.5 Eine Farbmischer-App. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48924.6 Picker-Einstellungen auslesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49224.7 Von Dezimal zu Hexadezimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493

25 Tabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49725.1 Die Showroom-App – der digitale Ausstellungsraum . . . . . . . . . . . . 49825.2 Wohin mit dem Daten-Model? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50125.3 Konfigurationen im Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . 50225.4 Der Tabellen-View-Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506


Inhaltsverzeichnis

11

25.5 Zweite Szene: Die Detailansicht. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51025.6 Ein neuer Segue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51325.7 Vorsicht, Fehlerquelle! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51725.8 Bilder anzeigen mit dem UIImageView . . . . . . . . . . . . . . . . . . . . . . . 518

26 Eye Candy – Unsere App soll schöner werden . . . . . . . . . . . . . . . . . . 52526.1 Angepasste Tabellenzellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52926.2 Ein Controller für die Tabellenzelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 53326.3 Abgerundete Ecken und Rahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53626.4 Settings – die Einstellungen einer App . . . . . . . . . . . . . . . . . . . . . . . . 53926.5 NSUserDefaults – die Benutzereinstellungen . . . . . . . . . . . . . . . . . . 54426.6 Standardeinstellungen erforderlich . . . . . . . . . . . . . . . . . . . . . . . . . . . 54626.7 Kommunikation mit der Nachrichtenzentrale . . . . . . . . . . . . . . . . . . 548

27 Der Collection View. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55327.1 Storyboard mit Collection View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55327.2 Der Collection View Controller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55727.3 Mit dem Segue zur Detailansicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56327.4 Teilen mit dem UIActivityViewController. . . . . . . . . . . . . . . . . . . . . . 56627.5 Drucken mit AirPrint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57027.6 Unterschiedliche Texte für unterschiedliche Dienste. . . . . . . . . . . . . 572

28 Zeichnen mit Core Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57728.1 Die Klasse UIView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57728.2 Rechtecke zeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58128.3 Frame und Bounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58528.4 Farbige Formen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59028.5 Speichern der Context-Einstellungen. . . . . . . . . . . . . . . . . . . . . . . . . . 59328.6 Zeichnen von Farbverläufen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59628.7 Arbeiten mit Beschneidungspfaden. . . . . . . . . . . . . . . . . . . . . . . . . . . 59928.8 Kurven und Figuren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603

29 Multi-Touch mit Gestenerkennung . . . . . . . . . . . . . . . . . . . . . . . . . . . 60929.1 Linien zeichnen einen Pfeil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60929.2 Einfache Berührungserkennung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61129.3 Wischgesten erkennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61329.4 Objekte bewegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61429.5 Pinch to Zoom – Vergrößern mit zwei Fingern . . . . . . . . . . . . . . . . . 61829.6 Verschiedene Gesten gleichzeitig erkennen . . . . . . . . . . . . . . . . . . . . 62229.7 Objekte drehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624


Inhaltsverzeichnis

12

29.8 Gesten im Konflikt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62629.9 Die Schüttelgeste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628

30 Digitale und analoge Uhren mit Timern . . . . . . . . . . . . . . . . . . . . . . . 63130.1 Die Klasse NSTimer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63130.2 Wie spät ist es? – Datum und Uhrzeit ermitteln . . . . . . . . . . . . . . . . 63530.3 Extensions für die Klasse NSTimer . . . . . . . . . . . . . . . . . . . . . . . . . . . 63630.4 Eine analoge Uhr mit Core Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . 64130.5 Ein Zifferblatt zeichnen mit Winkelfunktionen . . . . . . . . . . . . . . . . . 64530.6 Timer im Einsatz – die Uhr tickt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647

31 Lokale Benachrichtigungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65131.1 Lokale Benachrichtigungen mit UILocalNotification . . . . . . . . . . . . . 65231.2 Eingehende Nachrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65631.3 Benachrichtigungen anpassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65931.4 Push-Benachrichtigungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661

32 Karten und Koordinaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66332.1 Der Location-Manager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66432.2 Auswerten von Positionsinformationen. . . . . . . . . . . . . . . . . . . . . . . . 66632.3 Geocoding – Wo bin ich hier?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66932.4 Karten mit dem MKMapView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67232.5 Annotations – Anmerkungen auf der Karte . . . . . . . . . . . . . . . . . . . . 67832.6 Benutzerdefinierte Anmerkungen gestalten und anzeigen . . . . . . . . 681

33 Daten suchen und finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68533.1 Zugriff mit Key Value Coding. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68533.2 Schlüsselpfade und Aggregatfunktionen . . . . . . . . . . . . . . . . . . . . . . . 68833.3 Listen filtern mit NSPredicate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69233.4 Erweiterte Vergleiche, logische Operatoren und Closures . . . . . . . . . 69533.5 Prädikate mit regulären Ausdrücken . . . . . . . . . . . . . . . . . . . . . . . . . . 69733.6 Daten filtern für Tabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69833.7 Listen für den Tabellen-View-Controller . . . . . . . . . . . . . . . . . . . . . . . 70333.8 Suchen mit dem UISearchController. . . . . . . . . . . . . . . . . . . . . . . . . . 706

Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715


31

Kapitel 1

Datentypen und Optionals

Im grundlegenden Umgang mit Variablen und Werten sind sich die meistenmodernen Programmiersprachen sehr ähnlich und unterscheiden sich oft nur inder verwendeten Syntax. Swift ist dabei keine Ausnahme, und wenn Sie schon mitanderen Sprachen gearbeitet haben, wird Ihnen der Inhalt der nächsten Seitenbestimmt vertraut vorkommen. Trotzdem sollten Sie dieses Kapitel nicht über-springen, denn Swift bietet einige Besonderheiten und Anweisungen, die man inanderen Sprachen nicht findet. Selbst bei einfachen und alltäglichen Dingen, wiezum Beispiel der Addition von Variablen, können erfahrene Entwickler durchSwift 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 Play-ground Programmcode schreiben, wird Ihnen das Ergebnis Ihrer Arbeit oft sofortin einer Seitenleiste neben dem Texteditor angezeigt, die von Apple als Results Side-bar bzw. als Ausgabebereich bezeichnet wird. Dort können Sie leicht überprüfen,ob die eingegebenen Anweisungen korrekt sind und das gewünschte Ergebnis lie-fern. Der Spielplatz eignet sich hervorragend, um neue Dinge auszuprobieren undzu testen, oder sich – wie in unserem Fall – mit Swift vertraut zu machen.

Einen neuen Playground können Sie direkt vom Welcome-to-Xcode-Fenster auserstellen, das beim Start der Entwicklungsumgebung angezeigt wird. Wählen Siedort GET STARTED WITH A PLAYGROUND. Möchten Sie zu einem bereits bestehen-den Projekt einen Playground hinzufügen, führt der Weg über die MenüpunkteFILE, NEW und FILE...

Ein Playground der Plattform iOS unterscheidet sich von einem OS-X-Spielplatznur durch die Anweisung, mit der das zugehörige Framework für die grafischenOberflächen importiert wird. iOS-Apps arbeiten mit UIKit, während für OS X dasCocoa Framework importiert wird. Für unsere ersten Schritte benötigen wirjedoch nur das Foundation Framework und somit ist es egal, für welche PlattformSie den Playground erzeugen. Foundation ist sowohl in UIKit als auch in Cocoaenthalten. Nennen Sie Ihren ersten Playground Datentypen und speichern Sie dieDatei an einem Ort, an dem Sie sie später leicht wiederfinden. Sie sollten immer


Kapitel 1Datentypen und Optionals

32

bemüht sein, Ihre Projekte gut zu organisieren, um die Übersicht nicht zu verlie-ren und Dinge schnell finden zu können.

Nachdem Xcode den Playground angelegt hat, öffnet die Entwicklungsumgebungein in zwei Bereiche geteiltes Fenster. Die linke Seite ist der Editor, in den wirunsere Anweisungen schreiben können. Die rechte Seite wird als Ausgabebereichbezeichnet und dient zur Ausgabe von Werten und Variablen. Neben der import-


1.2Variablen und Konstanten

33

Anweisung und einem Kommentar gibt es im Programm sogar schon einenBefehl. Mit

wird der Variablen str der Text Hello, playground zugewiesen, der daraufhin imAusgabebereich angezeigt wird. Da wir uns mit Texten erst später beschäftigen,können Sie die Anweisung entfernen. Löschen Sie aber nicht versehentlich denimport-Befehl. Ohne ein geladenes Framework kann es in einem Swift-Pro-gramm zu verwirrenden Fehlermeldungen kommen, deren wahre Ursache nurschwer zu erkennen ist.

1.2 Variablen und Konstanten

Lassen Sie uns bei der Reise in die Welt der Swift-Programmierung mit etwasganz Einfachem beginnen. Wie alle modernen Programmiersprachen bietet Swiftdie Möglichkeit, im Programmcode Variablen zu deklarieren und ihnen Wertezuzuweisen. Der von Xcode vorbereitete Playground hat das mit seiner Anwei-sung schon gut demonstriert. Für verschiedene Anwendungsfälle kommen dabeidann unterschiedliche Datentypen zum Einsatz. Soll mit den Werten gerechnetwerden, fällt die Wahl in der Regel auf die Typen Int, Double oder Float, je nachder erforderlichen Genauigkeit. Das nachfolgende kurze Listing zeigt beispielhaftdie Definition zweier Variablen mit dem Befehl var und zwei unterschiedlichenDatentypen. Wenn Sie alle Anweisungen richtig eingegeben haben, wird Xcode imAusgabebereich des Playground-Fensters die Inhalte der Variablen anzeigen. Andieser Stelle erneut der Hinweis, dass die Anweisungen auch funktionieren, wennSie die Befehlszeilen aus Gewohnheit mit einem Semikolon abschließen.

var str = "Hello, playground"



34

Um welche Typen es sich bei den Variablen in unserem Code handelt, können Sievermutlich auch ohne jahrelange Erfahrung in der Softwareentwicklung und ohnedie explizite Angabe des Typs schnell selbst erkennen. Die Variable age ist eineganze Zahl, ein sogenannter Integer. Bei taxRate finden wir Nachkommastellen,sodass es sich um eine Dezimalzahl handeln muss. Dort sollte dann der TypDouble oder Float verwendet werden, denn als ganze Zahl ließe sich dieser Wertnur unvollständig ablegen.

Wie Sie sicher bestätigen können, geben die Werte selbst schon genau vor, welcherDatentyp verwendet werden muss, und so ist es in Swift oftmals gar nicht notwen-dig, den Typ einer Variablen bei der Definition explizit anzugeben. Der Compilerkann den Typ selbst erkennen. Die Definitionen der beiden Variablen würden inSwift daher auch so funktionieren:

var age:Int = 43

var taxRate:Double = 9.5

Wichtig

Für Variablennamen wird in Swift die Lower-Camel-Case-Schreibweise verwen-det. Der erste Buchstabe im Namen ist ein kleiner Buchstabe, alle weiteren Wör-ter, aus denen der Name gebildet wird, beginnen mit einem Großbuchstaben.Beispiele für aussagekräftige Namen wären arrayOfSelectedItems oderfirstDayInMonth. Unterstriche in Bezeichnern sind in Swift nicht üblich.

var age = 43

var taxRate = 9.5



35

Diese automatische Typerkennung des Compilers, die in der englischen Doku-mentation als »Type Inference« bezeichnet wird, funktioniert in Swift sehr gut,sodass bei den meisten Variablen auf eine explizite Angabe des Datentyps verzich-tet wird. Als Entwickler kann man jedoch sicher sein, dass der Compiler den rich-tigen Typ auswählt. Außerdem wird der Programmcode so kürzer und besserlesbar, worauf man bei Apple sehr viel Wert legt.

Für das Programm selbst ändert sich dabei jedoch nichts. Die Variable age ist wei-terhin eine ganze Zahl und für Dezimalbrüche wie taxRate wählt der Compilerimmer den Typ Double, weil dieser im Vergleich zu Float über eine größereGenauigkeit verfügt. Bei beiden Variablen wird der Typ aus den zuerst zugewiese-nen Werten ermittelt. Spätere Änderungen auf einen anderen Typ sind nicht mög-lich. Wurde eine Variable als Int festgelegt, können Sie ihr anschließend keineZeichenkette zuweisen. Das folgende Beispiel wird nicht funktionieren, wie Siein Ihrem Playground leicht ausprobieren können. Durch Anklicken des Fehler-symbols links neben dem Programmcode können Sie die Fehlermeldung ein- oderausblenden.

Die Deklaration und Definition einer Variablen muss in Swift keineswegs immerin einer Programmzeile geschehen, die Anweisungen können auf mehrere Zeilenverteilt werden. Jetzt ist der Compiler jedoch nicht mehr in der Lage, den Typ derVariablen selbstständig zu erkennen, und benötigt unsere Hilfe. Der Typ muss beider Deklaration wieder explizit angegeben werden.

var age = 43

var taxRate = 9.5

age = "19"



36

Wie groß der Wert einer Variablen sein kann, hängt teilweise von der Systemarchi-tektur ab, auf der das Programm ausgeführt wird. Auf einem 32-Bit-System wirdfür den Typ Int ein 32 Bit langes Datenwort verwendet, das den möglichen Wertauf einen Bereich von -2.147.483.648 bis 2.147.483.647 eingrenzt. Auf Systemenmit einer 64-Bit-Architektur ist Int ein 64 Bit langes Datenwort und kann Wertezwischen -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 dieDatentypen Int8, Int16, Int32 und Int64 verwendet werden. Der Typ Float istauf jedem System ein 32-Bit-Datenwort, Double hingegen immer 64 Bit lang. Wel-che Werte auf Ihrem System möglich sind, können Sie mit den folgenden vierAufrufen der print-Funktion herausfinden.

Ein Aufruf der Funktion print in einem Playground führt zu einer Ausgabe in derResults Sidebar. Dort wird der Wert direkt neben der zugehörigen Anweisungangezeigt. Der Ausgabebereich ist jedoch nicht der einzige Ort, an dem die Ent-wicklungsumgebung die Ausgaben von print anzeigt, zusätzlich werden sie indie Konsolenansicht geschrieben. Diese ist in der Standardkonfiguration einesPlaygrounds allerdings immer unsichtbar und muss erst eingeblendet werden.Die Schaltfläche HIDE OR SHOW THE DEBUG AREA aus der Symbolleiste erledigtdas. In der Konsole stehen die minimalen und maximalen Werte nicht neben den

var age:Int

var taxRate:Double

age = 43

taxRate = 9.5

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



37

Anweisungen, sondern erscheinen in der Reihenfolge, in der sie mit print ausge-geben wurden.

In Xcode-Projekten für iOS-Apps oder OS-X-Anwendungen steht Ihnen währendder Entwicklung kein Ausgabebereich zur Verfügung, und Ihre Anweisungen wer-den dort auch nicht automatisch sofort nach der Eingabe ausgeführt. Das funk-tioniert nur im Playground. Die Konsolenansicht gibt es jedoch auch dort undkann für Ausgaben genutzt werden. Zögern Sie nicht, print zu verwenden, umden Programmablauf Ihrer Anwendungen nachzuvollziehen oder Werte anzuzei-gen. Ein Aufruf von print verrät Ihnen nicht selten schneller etwas über Ihr Pro-gramm als die Analysewerkzeuge der Entwicklungsumgebung.

Wenn Sie den Mauspfeil auf einen Wert im Ausgabebereich bewegen, werden dortdie Schaltflächen für Inline Results und Quick Look sichtbar. Beide Funktionen bie-ten 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 ver-schwindet, sobald ein beliebiger anderer Punkt auf dem Bildschirm angeklicktwird. Die Ausgabe eines Inline Results bleibt sichtbar, bis sie wieder deaktiviertwird.

Während Variablen zur Laufzeit eines Programms jederzeit neue Werte, allerdingsnur desselben Typs, zugewiesen werden können, ist dies bei Konstanten nichtmöglich. Konstanten werden in Softwareprojekten daher oft zur Konfigurationeingesetzt, um Werte einer Anwendung leichter zu verwalten und »magische Zah-len« zu vermeiden. Dabei handelt es sich um Zahlenwerte, die direkt im Pro-grammcode stehen und deren Aufgaben oft nur schwer erkennbar sind. EineKonstante mit einem aussagekräftigen Namen kann dann sehr zur Lesbarkeit desCodes betragen.

In Swift werden Konstanten über den Befehl let erzeugt. Das nachfolgende Lis-ting zeigt die Definition der Zahl Pi sowie einer Serveradresse als Zeichenkette.



38

In den ersten Versionen von Swift war es bei einer Konstanten nicht möglich,Deklaration und Definition auf mehrere Programmzeilen zu verteilen, das funk-tionierte selbst dann nicht, wenn der Typ explizit angegeben wurde. Seit Swift 2.0können Deklaration und Definition getrennt werden, in vielen anderen Program-miersprachen funktioniert das bei Konstanten nicht.

Eine nachträgliche Änderung des zugewiesenen Wertes ist anschließend nichtmehr möglich. Eine Konstante ist unveränderlich, und der Compiler wird bei demVersuch, Änderungen vorzunehmen, Fehlermeldungen ausgeben.

1.3 Zahlendatentypen konvertieren

Nicht selten gibt es in Programmen Situationen, bei denen die Inhalte von mehre-ren Variablen zu einem Wert zusammengefasst werden müssen. Ein sehr gutesBeispiel sind mathematische Berechnungen, die aus einzelnen Werten ein Ergeb-nis ermitteln. Swift unterscheidet sich dabei nicht von anderen Programmierspra-chen und unterstützt eine Vielzahl von Rechenoperatoren. Wie nicht anders zuerwarten, gilt immer Punkt- vor Strichrechnung.

let pi = 3.14159265359

let server = "http://cocoa-coding.de"

let pi:Double

pi = 3.14159265359

let server:String

server = "http://cocoa-coding.de"

Wichtig

Swift und Xcode erlauben bei der Entwicklung die Verwendung sämtlicher Uni-code-Zeichen als Variablennamen. So können Sie beispielsweise statt des Varia-blennamens pi auch das Zeichen U+30C0 (Greek Small Letter Pi) verwenden.Inwieweit dies die Programmierung leichter und übersichtlicher macht, solltenSie für sich selbst entscheiden. Empfehlen kann man diese Vorgehensweise ver-mutlich nur in Ausnahmefällen.

let π = 3.14159265359

var a = 75

var b = 100

var c = 5

let sum1 = a + b * c

let sum2 = (a + b) * c


1.3Zahlendatentypen konvertieren

39

Beachtenswert im gezeigten Beispiel ist der Umstand, dass auch das Ergebniseiner Berechnung einer Konstanten zugewiesen werden kann. Im Unterschied zueinigen anderen Programmiersprachen muss der Wert einer Konstanten in Swiftnicht zwangsläufig während der Kompilierung bekannt sein, obwohl er sich in die-sem Beispiel durchaus ermitteln ließe. Sogar eine Textfeldeingabe, die erst nachdem Start der Anwendung vorgenommen wird, kann in Swift einer Konstantenzugewiesen werden.

Solange wir uns bei den Rechenoperationen auf nur einen Datentyp beschränken,können wir ohne Probleme programmieren. Schwierig wird es erst, wenn unter-schiedlichen Typen verwendet werden. Dann kann schon eine einfache Additionzu Problemen führen:

Auch ohne Angabe eines Typs können wir die Variable a als ganze Zahl und somitvom 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 nichtexplizit als Float angegeben wird. Doch welchen Typ muss man einsetzen, wenndie beiden Variablen addiert werden sollen? Mit einem weiteren Double wäresichergestellt, dass der Nachkommateil der Summe nicht verloren geht, aber inmanchen Situationen ist vielleicht genau das gewünscht und man möchte nurganze Zahlen. Weil der Swift-Compiler diese Entscheidung nicht eigenständigtreffen kann, führt die Addition zu einem Fehler. Schuld daran sind die unter-schiedlichen Datentypen. Leider ist die Meldung der Entwicklungsumgebungnicht 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, welcherTyp verwendet werden soll. Bei einer Berechnung, die sowohl Int als auchDouble-Typen verwendet, würde vermutlich ein Double für das Ergebnis verwen-det, um eine bestmögliche Genauigkeit zu gewährleisten. Allerdings gibt es keineRegel, dass dies so sein muss, und Programmiersprachen mit anderen Compilernkönnen sich anders verhalten. Damit der Entwickler sich nicht auf Vermutungen

var a = 75

var b = 3.8

// Die Addition unterschiedlicher Datentypen

// führt zu einer Fehlermeldung!

let sum = a + b



40

verlassen muss, ist in Swift eine implizite Konvertierung nicht möglich. Diegezeigte Fehlermeldung ist die Folge.

Bei einer expliziten Konvertierung muss der gewünschte Typ im Programm genaufestgelegt werden, was somit zu einer Aufgabe für uns Programmierer wird. Solldas Ergebnis vom Typ Double sein, müssen wir den Compiler anweisen, die Vari-able a vor der Addition mithilfe einer Funktion in einen Double-Typ zu konvertie-ren. Sind beide Summanden vom gleichen Typ, ergibt sich der Typ für die Summe.

Wollen wir unser Ergebnis lieber als ganze Zahl, muss die Variable b konvertiertwerden. Doch Vorsicht, gerundet wird die Zahl von der Int-Funktion nicht! DieNachkommastellen werden abgeschnitten, aus 3,8 wird 3 und die Summe derAddition somit 78! Mit einer expliziten Konvertierung erhalten wir immer dengewünschten Typ und sind nicht von der Entscheidung eines Compilers abhängig.

Die gezeigten Arten der Konvertierung entsprechen einer Umwandlung, die als»cast« oder »typecasting« bezeichnet wird, in Swift allerdings mit einer etwasungewöhnlichen Syntax. Viele andere Programmiersprachen verwenden eineSchreibweise, bei der dem zu konvertierenden Wert der gewünschte Typ in run-den Klammern vorangestellt wird. Dort sieht es so aus:

Möchte man in einem Swift-Programm zwei Int-Werte addieren, das Ergebnisaber als Double erhalten, ist das ebenfalls nur ein kleines Problem. In den rundenKlammern der Funktionen kann die Addition programmiert werden. So ist esnicht erforderlich, beide ganze Zahlen einzeln zu konvertieren.

// Die Double-Funktion:

// a wird zunächst in einen Double-Typ umgewandelt

// c wird so zu einem Double-Typ

var sumDouble = Double(a) + b

// Die Int-Funktion:

// b wird zunächst in einen Int-Typ umgewandelt

// c wird so zu einem Int-Typ

var sumInt = a + Int(b)

// Typecasting, wie es in anderen Sprachen

// angewendet wird.

// var sum = (Double)a + b

var x = 100

var y = 60

// Einzelne Konvertierung, nicht erforderlich


1.4Werte runden

41

1.4 Werte runden

Bei einer expliziten Konvertierung von Double zu Int sämtliche Nachkommastel-len abzuschneiden, kann gewünscht sein, doch nicht weniger oft möchte man denWert zuvor runden. Diese Aufgabe kann die Funktion round übernehmen. Wie Siemit den folgenden Anweisungen selbst ausprobieren können, wird ab einemNachkommawert von .5 aufgerundet, ansonsten wird abgerundet.

Soll der gerundete Wert dann zu einem Int-Typ werden, spricht nichts dagegen,verschiedene Anweisungen zu verschachteln. So kann man im Code eine Zeileeinsparen, ohne dabei allzu viel Lesbarkeit einzubüßen.

Zwei weitere wichtige Funktionen zur Manipulation von Double-Werten sindfloor und ceil. Sie liefern den nächstniedrigeren und nächsthöheren ganzzahli-gen Wert, vollkommen unabhängig vom Wert hinter dem Komma. Das Ergebnisist weiterhin ein Double.

// var sum = Double(x) + Double(y)

// Konvertierung der Summe

var sum = Double(x + y)

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

var a2 = 99.50

var r2 = Int(round(a2))

// r2 ist jetzt 100 und vom Typ Int

var aValue = 99.001

var c = ceil(aValue)



42

Einige Entwickler, die ich kennengelernt habe, hatten Schwierigkeiten, sich dieFunktionsweisen von floor und ceil zu merken und diese zu unterscheiden.Denken Sie dabei an die englischen Begriffe. floor ist der Fußboden und somitder niedrige, untere Wert. ceil ist eine Abkürzung für ceiling, die Zimmerdecke.Bei dieser Funktion bekommen wir den höheren, oberen Wert. Die Zimmerdeckeist 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 diesmit einer if-Struktur sicherlich leicht programmieren. Etwas eleganter sind die inSwift bereits vorhandenen Funktionen max und min.

Eine besondere Erklärung ist an dieser Stelle vermutlich nicht nötig. Erwähnens-wert ist jedoch, dass die beiden Funktionen in Swift auch mehr als zwei Werte ver-arbeiten können. Bei den ähnlichen Funktionen anderer Programmiersprachenist das nicht möglich. Allerdings müssen sämtliche Werte vom gleichen Typ sein,also ausschließlich Double, Float oder Int.

// c ist jetzt 100.0

var f = floor(aValue)

// f ist jetzt 99.0

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)

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


1.6Der Datentyp Bool

43

Eine Alternative zu min und max bieten die beiden Funktionen minElements undmaxElements, die jedoch beide eine Auflistung des Typs Array als Parametererwarten. Mit diesen Listen werden wir uns in Kapitel 3 noch genauer beschäfti-gen. Um die Funktionen auf unsere vier Variablen anzuwenden, genügt es für denAugenblick, die Bezeichner zusätzlich in eckige Klammern einzufassen. Sämtli-che Funktionen akzeptieren neben Variablen und Konstanten auch feste Werte,die unveränderlich im Programmcode stehen.

1.6 Der Datentyp Bool

Einen Datentyp, den man in diesem Kapitel nicht unterschlagen sollte, ist der TypBool, benannt nach dem englischen Mathematiker George Boole. Eine Variableoder Konstante des Typs Bool kann ausschließlich die Werte true oder falseannehmen und wird deshalb fast ausnahmslos dazu verwendet, um einebestimmte Aussage als wahr oder unwahr zu kennzeichnen. Wenn wir uns inKapitel 4 mit Fallunterscheidungen beschäftigen, wird der Typ Bool daher einegroße Rolle spielen.

In einigen anderen Programmiersprachen kann ein Bool alternativ durch Zahlen-werte gesetzt werden, wobei 0 einem false und jeder andere Wert einem true

// Double-Typen ermitteln

var maximum = max(m1,m2,m3,m4)

var minimum = min(m1,m2,m3,m4)

var minValue = minElement([m1, m2, m3, m4])

var maxValue = maxElement([4.5, 4.0, 3.9, 4.4])

// Zuweisungen boolescher Typen

// mit Angabe des Datentyps

var valueB1:Bool = true

// Ohne Angabe des Datentyps

var valueB2 = false



44

entspricht. Weil so die Lesbarkeit des Codes aber sehr beeinträchtigt wird, gibt esdiese Möglichkeit in Swift 2.0 nicht mehr. Die aus Objective-C bekannten WerteYES und NO funktionieren in Swift ebenfalls nicht.

1.7 Optionals

Einer der größten Unterschiede zwischen Objective-C und Swift ist die Möglich-keit, Variablen und Konstanten im Programmcode als Optional zu deklarierenund ihnen damit die Fähigkeit zu geben, alternativ zu einem Wert den Zustandnil anzunehmen. Ein Optional ist nil, wenn ihm noch kein Wert zugewiesenwurde oder sein Zustand explizit unbestimmt sein soll.

Haben Sie das alles sofort verstanden? Zugegeben, das klingt sehr technisch, aberso ist die Softwareentwicklung gelegentlich. Möchte man Optionals an einem Bei-spiel aus dem Alltag erklären, muss man dafür ein wenig ausholen:

Stellen Sie sich ein digitales Thermometer vor, dessen gemessene Temperatur voneiner Software verwaltet und angezeigt werden soll. Im Sommer erreicht das Ther-mometer Temperaturen von über 30 Grad, im Winter hingegen Werte unter 0Grad. So ergibt sich ein großer Bereich von möglichen Temperaturen, wobei essich immer um Dezimalzahlen handelt. In der Software scheint der DatentypDouble daher bestens geeignet, die ermittelte Temperatur aufzunehmen und zurAnzeige zu bringen. Wie Sie inzwischen wissen, müssen Variablen und Konstan-ten aber mit einem Wert initialisiert werden, bevor man das erste Mal lesend aufsie zugreifen kann. Es gibt Situationen, in denen eben dies zu einem Problemwird.

Solange das Thermometer funktioniert, hat das Programm mit der Temperaturund dem Typ Double keine Schwierigkeiten. Problematisch wird es erst, wenn dasThermometer ausfällt oder von der Software aus einem anderen Grund keineDaten mehr empfangen werden können. Mit welcher Temperatur haben wir esdann zu tun und welcher Wert soll dann angezeigt werden?

Eine Möglichkeit wäre es, die Variablen mit dem Wert 0 zu initialisieren undsomit 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 inunserem Bereich, und wenn im Programm mit diesem Wert gearbeitet wird, sollteman davon ausgehen können, dass die Temperatur so gemessen wurde. Die Soft-ware benötigt zusätzliche Informationen darüber, ob ein gemessener Wert vor-

// Alternative Zuweisung von Zahlen

// Funktioniert in Swift 2.0 nicht mehr

var value1:Bool = 1

var value2:Bool = 0


1.7Optionals

45

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 tat-sächlich um eine gemessene Temperatur handelt, ließe sich mit einer zusätzli-chen booleschen Variablen abbilden. Oder Sie verwenden einen Optional!

In Swift kann jeder Typ zu einem Optional werden, allerdings ist es bei der Defini-tion einer Variablen oder Konstanten erforderlich, diese Erweiterung explizit anzu-geben, denn dass eine Variable oder Konstante ein Optional sein soll, kann derCompiler nicht eigenständig erkennen. Er würde immer einen regulären Typ ein-setzen 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 einFragezeichen 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 Playgroundeingeben, wird Ihnen Xcode für die Variable temperatur1 den Wert 32.5 im Aus-gabebereich ausgeben. Für temperatur2 erhielten Sie in der Vergangenheit dieAusgabe { Some 32.5}, wobei Some ein Hinweis auf einen Optional war. In dermomentan aktuellen Xcode-Version wird das Some leider nicht mehr angezeigt.

Eindeutig werden die Informationen der Entwicklungsumgebung, wenn Sie diebeiden Variablen mit der print-Funktion ausgeben. Zusätzlich zum Wert fürtemperatur2 wird jetzt das Wort Optional angezeigt.

// Definition einer Variablen

var temperatur1:Double = 32.5

// Definition einer Variablen als Optional

var temperatur2:Double? = 32.5

...

// Ausgabe der beiden Variablen

print(temperatur1)

print(temperatur2)



46

Besonders interessant verhält sich der Playground, wenn Sie für die beiden Varia-blen die Zuweisungen der Werte entfernen. Die Variable temperatur2 ist einOptional und kann legitim ohne Wert verwendet werden. Ihr Zustand ist dannautomatisch nil und genau das wird im Ausgabebereich angezeigt, sobald mandie Zuweisung entfernt.

Löscht man die Zuweisung für die Variable temperatur1, kommt es sofort zueiner Fehlermeldung. Eine reguläre Variable muss vor der ersten Verwendung miteinem Wert initialisiert werden, sonst kann sie nicht ausgegeben werden.

In Objective-C bekam man es mit nil zu tun, wenn ein Speicherzeiger auf keingültiges Objekt verwies, und das war nicht immer ein gewünschter Zustand. InSwift ist nil bei einem Optional hingegen ein legitimer Wert. Er sagt aus, dass esfür die Variable keinen Wert gibt. Um dies zu ermöglichen, muss der Typ aberexplizit 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 zumEinsatz kommen könnte, zeigt das folgende Beispiel. Ist die Variable temp gleichnil, wird der Text Keine Messung ausgegeben, gibt es hingegen einen Wert, fin-den wir stattdessen die Temperatur im Ausgabebereich. Probieren Sie das in IhrerEntwicklungsumgebung aus.

// Definition einer Variablen

var temperatur1:Double = 32.5

// Definition einer Variablen als Optional

var temperatur2:Double?

// Ausgabe der beiden Variablen

print(temperatur1)

print(temperatur2)


1.8Programmieren mit Optionals

47

Vereinfacht beschrieben, hat man es bei einem Optional immer mit zwei Wertenzu tun. Wird eine Variable oder Konstante mit ihrem Namen angesprochen, kannman ausschließlich Informationen darüber erhalten, ob der Optional nil ist odernicht. Ist der Zustand nicht nil, muss zunächst ein »Auspacken« stattfinden(Unwrapping in der englischen Dokumentation), um an den eigentlichen Wert zugelangen. 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 Ent-wicklungsumgebung 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 Feh-ler. Vergleiche mit der if-Struktur werden wir uns in den folgenden Kapitelngenauer 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 wirdder Optional in der if-Struktur einer neuen Konstanten oder Variablen zugewie-sen. Ist die Zuweisung erfolgreich, ist der Wert also nicht nil, erhält man denWert automatisch in einer regulären Variablen, die aber nur innerhalb der if-Struktur verwendet werden kann.

var temperatur:Double? = 18.2

if temperatur == nil

{

print("Keine Messung")

}

else

{

print(temperatur!)

}

var temperatur:Double? = 18.2

if let temp = temperatur

{

print(temp)

}

else

{

print("Keine Messung")

}



48

Für Umsteiger ist das Optional Binding vielleicht etwas gewöhnungsbedürftig, eslohnt sich aber sehr, diese Schreibweise zu verwenden, da sie zu kurzem undübersichtlichem Code führt. Optionale Typen kommen in Swift bei vielen Klassenund Strukturen zum Einsatz, sodass wir uns später noch mal mit diesem Themabeschäftigen werden.


715

Stichwortverzeichnis

Symbole#define 306

AActivity Item 567Adresse

ermitteln 669advancedBy 64Aggregatfunktion 692AirPrint 570Alias 121Analoge Uhr

mit Zeigern 641Animierter Übergang 428Annotation 678Anonymer Typ 112AnyObject 70, 76, 202, 297, 359, 637Application Kit 24Argumente 103Array 67as-Anweisung 392Assertion 260Assistant Editor 354Assistent 333Associated Values 227Assoziation 191Ausgabebereich 32Ausrichtung

verhindern 565Autolayout 317, 331Automatic Reference Counting 174, 247

BBadge 659Bar Button Item 396, 405Benachrichtigung 652Benannter Parameter 104, 107Beobachter-Entwurfsmuster 475Berechnete Eigenschaft 157Berührungserkennung 611Beschneidungspfad 599Bézierkurve 603Bilddatei

hinzufügen 521

Binärzahl 230Bit 230Bitmuster 230Bool 43Boolescher Operator 83, 84break 87, 95Bundle 657Button 291

Ccatch 242ceil 41CGColor 582CGFloat 495, 560CGPoint 439CGRect 439CGRectMake 439, 579, 583, 644CGSize 439characters 52Checkbox 440CLGeocoder 669Clipping Path 599CLLocationManager 664Closed Range 89Closure 71, 126, 459, 637, 669, 696Coalescing Operator 198Cocoa Framework 24Cocoa Touch Framework 26Collection View 553Combobox 478compare 53Completion Handler 128Constraints 317

aktualisieren 390automatisch anpassen 321

continue 96Controller 295Convenience Initializer 191, 214, 479, 493Core Graphics 577, 642Core Location 663count 52, 69

DDateinamen

anhängen 467



716

Datumermitteln 635

Debugger-Ansicht 88Debug-Version 261default 87deinit 174, 380, 634Delegate 403, 423Delegation 423Designated Initializer 172, 189, 192, 380, 479Dezimaltrennzeichen 363Dictionary 73, 284, 456, 660dispatch_after 139dispatch_async 141distanceTo 62Double Tap 626dropFirst 66dropLast 66Drucken 571

EEigenschaft 156

berechnete 157Eingabefeld 329Ellipse 592Ellipsis Operator 115else if 82E-Mail 567Emoji 63Enumeration 220Erinnerung 652Error-Handling 239ErrorType 241Explizite Konvertierung 40Extension 207, 637External Parameter Name 108

FFacebook 567Factory-Methode 176Failable Initializer 172, 195fallthrough 86Farben 482Farbmischer 489Farbverlauf 596Fast Enumeration 91filter 73Filtern 692first 65First Responder 341floor 41fmin 643for-in-Schleife 89, 91format 51Format Specifier 51, 360, 494, 635

for-Schleife 88, 286, 645, 702Forward Geocoding 670Foundation Framework 25, 31, 153Frame 439Funktion 103

GGeocoding 669Gestenerkennung 609Getter 158, 177GPS-Sensor 665Grafik

für Retina-Display 421Grand Central Dispatch 138Groß- und Kleinschreibung 53, 71, 80guard-Struktur 235Gültigkeitsbereich 99

HHalf-Open Range 89hasPrefix 80hasSuffix 79Human Interface Guidelines 293

IIBAction 295, 305

erstellen 336IBOutlet 295, 305

erstellen 335Icon 324if-Struktur 79Implizite Konvertierung 39Indexpositionen 113indices 62Info.plist 663, 708init 170Inline Closure 135Inline Result 37, 97, 104, 105inout 120Inspector 289Instanziierung 155Instanzvariable 156Interface Builder 288internal 155iOS-Simulator 280

Ausrichtung 316Home-Button 281Koordinaten eingeben 668

isEmpty 52, 157isKindOfClass 614Iteration 91

JJumpbar 257, 336, 533



717

KKapselung 169, 404, 501, 685Karte 663

Callout 682eigenen Ort anzeigen 672Maßstab 676Stecknadel 681

kCFBundleNameKey 657Key Path 688Key Value Coding 685, 686Key Value Pair 74Klasse 155

anlegen 153Klassenmethode 639Kombinationslistenfeld 478Kommentar 23, 251

In Jumpbar 257Konstante 37, 75Konstanten als Parameter 119Kontrollstruktur 79Konvertierung

explizite 40implizite 39

Koordinatensystem 583

Llast 65Laufvariable 88Launch Screen 325Layer 537Lazy Loading 315locale 59Lottozahlengenerator 282lowercaseString 54, 80

MMakro 310Map Kit 663map-Methode 130Markdown 253Markup-Ansicht 253Master-Detail-Beziehung 497, 510max 42maxElements 43Mehrfachvererbung 191Methode 167Methodenaufruf 445min 42minElements 43Mitteilungszentrale 655MKAnnotationView 679, 681MKCoordinateSpanMake 676MKMapView 672, 679

MKPointAnnotation 678Modulo Operator 94, 525MVC-Entwurfsmuster 277

NNachrichtenzentrale 473Named Parameter 108Navigation Controller 381Navigation Item 391Navigationsleiste 390NSCalendar 647NSCoding 464NSDate 635, 647NSDateFormatter 635NSFileManager 469NSFormatter 667NSKeyedArchiver 464NSLocale 635NSNotificationCenter 473, 548NSNumber 60NSNumberFormatter 58, 491NSObject 465, 686NSPredicate 693NSString 49NSTimer 631, 632NSURL 467NSUserDefaults 544

OObjective-C 49, 154, 174, 247, 305Objekt 155

bewegen 614identifizieren 447

Observer 474Observer Pattern 475Optional 44, 58, 74, 193, 235, 409Optional Binding 47, 55, 102Optional Chaining 196, 206OptionSetType 231Outline View 294, 323, 353, 375, 420override 186, 315, 380, 465

PPainter Model 583Pan 614Parameter 103

benannter 104, 107variadischer 115

Parameter Ellipsis 115Pattern-Match Operator 84Picker 478Picker-Steuerelement 478Pinch to Zoom 609, 618



718

Playground 31Position des Geräts

ermitteln 663Prädikat 692Präprozessor-Makro 264print 36, 153Printer Simulator 570private 155, 168Project-Navigator 150Property List 540Property List Editor 540Property Observer 163Protokoll 199, 400Prototype Cell 505, 508public 155Punktnotation 157Punktnotations-Syntax 686Push-Benachrichtigung 661

QQuartz 2D 577Quick Look 37

RRange 55rangeOfString 55, 62Read-Eval-Print Loop (REPL) 66Rechteck

mit abgerundeten Ecken 536zeichnen 581

Refactoring 373Referenzzähler 246Regular Expressions 697Regulärer Ausdruck 697Relationship Segue 418Release Build 261repeat-while-Schleife 94Repository 435, 463, 499, 559, 699Results Sidebar 36Retina-Display 521reverse 92Reverse Geocoding 669Richtlinien 663round 41Rückgabetyp 110Rückgabewert 110RunLoop 636

SSchieberegler 352Schlüssel 74Schlüsselpfad 688

Schriftart 531Schriftgröße 531Schüttelgeste 628Schwenk 614Scope 99Segue 375, 405, 417, 513

anlegen 376Sektion 506Selektor 633Semikolon 33sendAsynchronousRequest 143Serialisierung 455setNeedsDisplay 649Setter 159, 177Settings Bundle 539, 547sort 72sortInPlace 71Speicheradresse

vergleichen 431Speicherzeiger 49Steuerelement

erzeugen 439Storyboard 371, 378, 415

erweitern 371in Navigation einbetten 390mit Datenübergabe 381

String 49String Dependency 220, 517, 688String Interpolation 50stringByTrimmingCharactersInSet 57Struktur 213Subscript 67Subscripting 63substringFromIndex 61substringToIndex 61Suchen 706Suchleiste 706Swipe 615switch-case-Struktur 85Symbol

für Schaltfläche 420Szene 372

ausblenden 410verlassen 379

TTabellenzelle 503Table View Cell 503Tableiste 416Tableisten-Controller 417Tag 447Tap 615Target-Action-Entwurfsmuster 445, 612



719

Tastatur 338ausblenden 341auswählen 338virtuelle 329

Textveröffentlichen 573

Texte verketten 50throw 241Timer 631Tupel 112Twitter 567Typ

anonymer 112Type Inference 35, 77typealias 637

UÜbergang

animierter 428Überladung 105Uhr

analoge 641Uhrzeiger 647Uhrzeit 631

ermitteln 635UIActivityViewController 566UIAlertView 347UIApplication 424, 472UIApplicationDelegate 403UIButton 291UICollectionView 553UICollectionViewCell 553UICollectionViewController 558UIColor 478, 489, 493, 582UIControl 340UIControlState 385UIEdgeInsets 560UIGestureRecognizer 609UIImageView 518, 529, 534, 562UIKit Framework 277UILabel 292, 307, 442UILocalNotification 652UINavigationController 395, 565UINavigationItem 523UIPanGestureRecognizer 614UIPickerView 482, 489UIPickerViewDataSource 484UIPinchGestureRecognizer 619UIRotationGestureRecognizer 624UISearchController 706UISlider 352, 404UIStoryboardSegue 392UISwipeGestureRecognizer 613

UISwitch 471UITableView 498, 503, 698UITableViewCell 503, 529, 533UITableViewController 503, 703UITableViewDataSource 510UITableViewDelegate 510UITapGestureRecognizer 612UITextField 329UIView 577UIViewAnimationTransition 429UIViewController 295, 308, 417Unicode 63Unit-Tests 268uppercaseString 54

VVariable 33Variablenname 34Variadischer Parameter 115Vererbung 181viewDidAppear 379viewDidLoad 307, 379viewWillAppear 379Virtuelle Tastatur 329

Wweak 394Weiterleiten

Informationen 566Wertepaar 74while-Schleife 93Whitespace 56Winkelfunktion 645Wischgeste 613Workspace-Fenster 150Wörterbücher 73

XXCTAssertNotNil 269XCTFail 268

ZZahlentypen umwandeln 50, 57Zeichenketten

teilen 61vergleichen 52

Zelleneinfärben 525Höhe 525

Zifferblatt 645Zirkelverweis 249Zufallszahl 284


iOS-Apps mit Swift 21).pdf · Inhaltsverzeichnis 11 25.5 Zweite Szene: Die Detailansicht. . . . . ....

Documents

Transcript of iOS-Apps mit Swift 21).pdf · Inhaltsverzeichnis 11 25.5 Zweite Szene: Die Detailansicht. . . . . ....