Inhaltsverzeichnis

Danksagung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9

Einleitung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

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 Datenyp Bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Optionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Programmieren mit Optionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

23 23 26 30 34 35 37 37 41

2 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8

Zeichenketten des Typs String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . String-Interpolation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zeichenketten vergleichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Textabschnitte finden und ersetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . Zeichenketten in Zahlentypen konvertieren . . . . . . . . . . . . . . . . . . . . Die Klasse NSNumber . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Texte teilen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Subscripting mit Unicode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anfang und Ende von Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . .

43 44 47 50 54 56 58 60 63

3 3.1 3.2 3.3

Arrays und Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Arrays – Listen von Elementen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Arrays sortieren und filtern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dictionaries, die schnellen Wörterbücher . . . . . . . . . . . . . . . . . . . . . .

67 67 72 75

4 4.1 4.2 4.3 4.4 4.5

Fallunterscheidungen und Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . Die if-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die switch-case-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Schleifen und Array. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rückwärts durch die for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

81 81 88 91 94 96

5

Inhaltsverzeichnis

6

4.6 4.7 4.8 4.9

Die while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Schleifen mit Fallunterscheidungen . . . . . . . . . . . . . . . . . . . . . . . . . . Diagramme im Ausgabebereich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Gültigkeitsbereiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

98 100 103 106

5 5.1 5.2 5.3 5.4 5.5 5.6 5.7

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

111 111 115 117 121 124 128 131

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

135 135 137 142 147 151 154 157

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

161 161 164 169 171 173 174 178

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

185 188 191 194 195 198

Inhaltsverzeichnis

9 9.1 9.2 9.3 9.4 9.5 9.6 9.7

Vererbung und Assoziationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Erbe der Klasse Person . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Erweiterungen der abgeleiteten Klasse . . . . . . . . . . . . . . . . . . . . . . . . Methoden überschreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Initialisierung abgeleiteter Klassen . . . . . . . . . . . . . . . . . . . . . . . . Assoziationen – Beziehungen zwischen Objekten . . . . . . . . . . . . . . . Optional-Chaining . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Coalescing-Operator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

201 201 205 207 210 214 219 223

10 10.1 10.2 10.3 10.4

Protokolle und Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein eigenes Protokoll entwickeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Protokolle statt Datentypen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Optionale Protokolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

225 226 229 232 235

11 11.1 11.2 11.3 11.4 11.5

Strukturen und Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zurück zum Spielplatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Strukturen oder Klassen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . String Dependencies – Abhängigkeiten von Zeichenketten . . . . . . . Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Enumerationen mit Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

239 239 243 247 248 251

12 12.1 12.2 12.3 12.4 12.5 12.6 12.7 12.8 12.9 12.10

Lotto – 6 aus 49. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MVC: Model-View-Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Projektvorlage – Cocoa Application . . . . . . . . . . . . . . . . . . . . . . . . . . . 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? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . One more thing ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

255 255 257 259 266 268 270 274 279 283 284

Swift Lexikon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

287

Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

311

7

Einleitung Schnell, modern und sicher. Mit diesen drei Eigenschaften wurde die Programmiersprache Swift beschrieben, als sie am 1. Juni 2014 auf der WWDC-Konferenz in San Francisco erstmalig der Öffentlichkeit vorgestellt wurde. Für die Entwickler war dies eine große Überraschung, denn seit über 20 Jahren wurde bei der Firma Apple mit Objective-C programmiert, einer Sprache, die sich besonders in den letzten Jahren steigender Beliebtheit erfreute. Sollte jetzt alles neu und anders werden? Die Antwort auf diese Frage ist einfach: Ja! Tatsächlich bringt Swift Möglichkeiten für OS-X- und iOS-Projekte, die es in anderen Programmiersprachen schon seit vielen Jahren gibt. Typsicherheit, Closures und Optionals sind nur einige der Schlagwörter, mit denen Apple dafür sorgt, dass bei einigen Programmierern das Herz schneller schlägt. Sollten Ihnen die Begriffe bisher nichts sagen, dürfen Sie sich davon aber nicht zu sehr beeindrucken lassen. Sie werden diese, und viele andere, auf den folgenden Seiten noch sehr genau kennenlernen. Wie bei allen neuen Dingen ist die Skepsis der Entwickler zunächst groß, denn das Erlernen einer weiteren Programmiersprache braucht immer Zeit, und die ist für viele Programmierer, besonders jene, die mit der Softwareentwicklung ihren Lebensunterhalt verdienen, gleichbedeutend mit Geld. Allerdings ist auch Apple ein Unternehmen, das Profit erwirtschaften will, und eine neue Programmiersprache zu entwickeln, ist sicherlich kein Hobbyprojekt. Vermutlich verspricht man sich von Swift für Entwickler einen leichteren Zugang zu den Plattformen OS X und iOS und somit zusätzliche und vielleicht auch bessere Anwendungen.

11

Einleitung

Wie die Zukunft für Swift aussehen wird, kann momentan niemand sagen. Es scheint aber unwahrscheinlich, dass Apple sowohl ObjectiveC als auch Swift weiterentwickeln wird. Dass bisher nur wenige Menschen mit Swift vertraut sind, ist hingegen sicher. Der Zeitpunkt, diese neue Sprache zu lernen, war daher nie besser. Dies ist Ihre Chance!

An wen richtet sich das Buch? Trotz meiner guten Vorsätze, eine wirklich einfache Einführung der Sprache Swift zu schreiben, fängt auch diese Buch leider nicht bei Null an. Dafür reichen die zur Verfügung stehenden Seiten leider nicht aus. Wenn Sie als Leser aber schon ein wenig Erfahrung in einer anderen objektorientierten Programmiersprache haben und jetzt Swift lernen wollen, sollten die Beispiele für Sie keine großen Hürden sein. Dabei ist es auch unerheblich, ob Sie Vollzeitentwickler oder nur Hobbyprogrammierer sind. Sind Begriffe wie Compiler, Objekte und Vererbung für Sie keine Fremdwörter, dann steht Ihnen der Weg offen, ein erfolgreicher Swift-Entwickler zu werden! Swift ist vielen anderen Programmiersprachen sehr ähnlich, aber trotzdem werden sich die ersten Kapitel mit einfachen Dingen wie Datentypen und Kontrollstrukturen beschäftigen, denn selbst dort gibt es Besonderheiten. Ein Schwerpunkt liegt außerdem in der Verarbeitung und Manipulation von Zeichenketten, da fast kein Programm ohne die Ausgabe von Texten auskommt. Zusätzlich werden Sie Apples Entwicklungsumgebung Xcode kennenlernen, die in der aktuellen Version um einen »Spielplatz« erweitert wurde, mit dem man Swift besonders gut lernen kann. In den weiteren Kapiteln folgen dann ein wenig anspruchsvollere Themen wie Arrays, Dictionaries, Funktionen, Klassen und Methoden. Falls Ihnen Tuples, Optionals und Closures noch nicht vertraut sind, werden Sie diese ebenfalls kennenlernen. Nicht fehlen dürfen selbstverständlich die Themen Vererbung und Protokolle. Was wäre die objektorientierte Programmierung ohne sie?

12

Swift ist nicht Objective-C Version 3.0

Swift ist nicht Objective-C Version 3.0 Bevor es im nächsten Kapitel mit der Swift-Entwicklung losgehen kann, sind einige einführende Worte über die Programmiersprache nötig. Das gilt besonders für alle Entwickler, die bisher mit Objective-C auf den Apple-Plattformen gearbeitet haben. Einige Dinge, die Ihnen seit Jahren vertraut sind, funktionieren jetzt anders und müssen neu erlernt werden. Sieht man sich als erfahrener Entwickler den Quellcode eines SwiftProgramms an, bekommt man schnell den Eindruck, es mit einer weiteren auf C basierenden Sprache zu tun zu haben. Tatsächlich ist die Syntax von Swift anderen Sprachen der C-Familie in manchen Bereichen ähnlich, unterscheidet sich aber in anderen Teilen genauso oft. Swift ist zweifellos mit C verwandt, aber keineswegs mit der Sprache kompatibel. Das war bei Objective-C, der Sprache mit der für die ApplePlattformen bisher bevorzugt entwickelt wurde, anders. Sie können in Apples Xcode-Entwicklungsumgebung ein Objective-C-Projekt anlegen und dort ohne weitere Anpassungen 20 Jahre alten C-Code einfügen, ohne auf Probleme zu stoßen. Mit Swift funktioniert das nicht mehr. Die Sprache hat den Anspruch, sicher zu sein und muss deshalb Anforderungen erfüllen, auf die man in der Vergangenheit weniger Wert legte. So ist es beispielsweise nicht mehr möglich, bei einer ifStruktur auf den Block aus geschweiften Klammern zu verzichten. Einige andere Programmiersprachen erlauben das, wenn nur ein Befehl bedingt ausgeführt werden soll, aber es ist dann auch nur genau eine Anweisung. Ist der Programmcode jedoch ungünstig formatiert, kann es bei dem Entwickler leicht zu Fehlinterpretationen kommen. Mit Swift hat Apple sich das Ziel gesetzt, solche und ähnliche Situationen zu vermeiden. Nicht mehr schreiben muss man hingegen die runden Klammern, mit denen in vielen anderen Sprachen die Bedingung der if-Struktur eingeklammert wird. Im Gegensatz zu dem Block aus geschweiften Klammern erhöhen sie weder die Lesbarkeit noch die Sicherheit des Codes und auch sonst haben die Klammern keinen weiteren Nutzen.

13

Einleitung

var value = 10000 if value == 10000 { println("Der Wert ist 10.000!") } else { println("Der Wert ist nicht 10.000.") }

Ein Semikolon nach einer Anweisung ist in Swift ebenfalls nicht mehr erforderlich, der Compiler kann das Ende eines Befehls ohne diese Markierung erkennen. Sollten Sie trotzdem weiterhin Semikolons schreiben, vielleicht weil Sie das aus jahrelanger Gewohnheit automatisch tun, wird Ihr Code trotzdem akzeptiert. Nötig wird ein Semikolon nur, wenn Sie mehrere Anweisungen in eine Zeile schreiben wollen. Um den Programmcode lesbar zu halten, sollte man dies aber vermeiden. Wie Sie in den folgenden Beispielen sehen werden, benötigt ein SwiftProgramm auch nicht zwingend eine main-Methode, um starten zu können. Natürlich ist es wichtig, den Startpunkt einer Anwendung genau festzulegen, allerdings ermöglicht Swift auch Programme, die anders arbeiten. Ein »Playground« kann ein vollwertiges Programm in einer Datei abbilden, die von oben nach unten abgearbeitet wird. Im nächsten Kapitel werden wir uns mit diesem Dokumententyp und seinen Möglichkeiten detailliert beschäftigen. Sind Sie bereits Entwickler für die Apple-Plattformen, werden Sie vermutlich die eckigen Klammer vermissen, die in Objective-C immer zum Einsatz kamen, wenn mit Klassen und Objekte programmiert wurde. Auf diese besondere Syntax wurde in Swift ebenfalls verzichtet. Die Sprache verwendet stattdessen für Eigenschaften und Methodenaufrufe die Punktnotation, wie sie in Java und C# schon seit vielen Jahren üblich ist. Auch das Konzept, dass sämtliche Objekte im Speicher unabhängig voneinander existieren und nur durch Nachrichten mitei-

14

Kommentare

nander kommunizieren, wird bei Swift nicht mehr angewendet. Dies führt zwar gegenüber Objective-C zu Einbußen in der Flexibilität, ermöglicht Swift im Gegenzug aber schnellere Methodenaufrufe.

Kommentare Die Syntax der Schreibweise von Kommentaren hat sich im Vergleich zu C und Objective-C nicht verändert. Es gibt weiterhin zwei verschiedene Möglichkeiten, Anmerkungen im Programmcode zu hinterlegen. Die erste und einfachste ist die Kommentarzeile, eingeleitet durch zwei Schrägstriche. // Dies ist ein Kommentar.

Kommentarzeilen eignen sich gut, um Variablen zu beschreiben. Es ist sogar möglich, den Kommentar direkt hinter einer Anweisung einzufügen. Nach den zwei Schrägstrichen wird der noch folgende Text zu einem Kommentar. // Das Alter der Person var ageOfPerson:Int = 45 var salaryOfPerson:Int = 45000 // Das Gehalt der Person

Möchte man mehr als eine Zeile Kommentar in den Code einfügen, können komplette Abschnitte als Kommentarblock ausgewiesen werden. Mit der Zeichenfolge /* beginnt ein solcher Block, der mit */ wieder beendet wird. Neben dem Einsatz zur Dokumentation können Kommentarzeilen und Kommentarblöcke verwendet werden, um Anweisungen vorübergehend aus einem Programm zu entfernen. So müssen die Befehle nicht gelöscht werden, falls man sie zu einem späteren Zeitpunkt wieder benötigt. // Eine auskommentierte Anweisung /* var tax:Double = 0.19 */

15