Erhalten Sie Zugang zu diesem und mehr als 300000 Büchern ab EUR 5,99 monatlich.
- Herausgeber: Carl Hanser Verlag GmbH & Co. KG
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Deutsch
- Veröffentlichungsjahr: 2017
Swift 3 für Ein- und Umsteiger – von den Basics bis zu fortgeschrittenen Techniken
Der unentbehrliche Begleiter für alle, die mit Swift 3 ihre eigenen Apps programmieren wollen. Sowohl komplette Neueinsteiger als auch erfahrene Programmierer lernen fundiert und mithilfe von Beispielen, die Sprache optimal einzusetzen. Darüber hinaus erhalten Sie eine komplette Referenz der Sprache.
Swift 3 von Grund auf verstehen
Von der grundlegenden Erstellung von Variablen, Konstanten und Funktionen über die objektorientierte Programmierung mittels Klassen und Methoden bis hin zu Subscripts, Generics und Access Control vermittelt Ihnen Autor Thomas Sillmann sämtliche Sprachmerkmale und Besonderheiten von Swift. Dabei berücksichtigt er auch fortgeschrittene Themen wie Swift als protokollorientierte Programmiersprache und zeigt ausführlich, wie Sie Ihren Code mit Playgrounds testen können.
Objective-C-Code weiter verwenden
An jeweils passender Stelle werden Vergleiche zwischen Swift und Objective-C angestellt, so dass Objective-C-Entwickler schnell erkennen, wie sie bestimmte Aufgaben mit Swift angehen und lösen. In einem Extra-Kapitel wird außerdem gezeigt, wie Sie Objective-C- und Swift-Code mischen und bestehende Projekte nach Swift migrieren können.
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 643
Das E-Book (TTS) können Sie hören im Abo „Legimi Premium” in Legimi-Apps auf:
Ähnliche
Thomas Sillmann
Swift 3 im Detail
Einführung und Sprachreferenz
1. Auflage
Der Autor:
Thomas Sillmann, Aschaffenburg, www.thomassillmann.de
Alle in diesem Buch enthaltenen Informationen, Verfahren und Darstellungen wurden nach bestem Wissen zusammengestellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Buch enthaltenen Informationen mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autor und Verlag übernehmen infolgedessen keine juristische Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen – oder Teilen davon – entsteht.
Ebenso übernehmen Autor und Verlag keine Gewähr dafür, dass beschriebene Verfahren usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Buch berechtigt deshalb auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen und MarkenschutzGesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.
Bibliografische Information der Deutschen Nationalbibliothek: Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
Dieses Werk ist urheberrechtlich geschützt. Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren) – auch nicht für Zwecke der Unterrichtsgestaltung – reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden.
© 2017 Carl Hanser Verlag Münchenwww.hanser-fachbuch.de
Lektorat: Sylvia Hasselbach Copyediting: Walter Saumweber, Ratingen Herstellung: Irene Weilhart Umschlagdesign: Marc Müller-Bremer, München, www.rebranding.de Umschlagrealisation: Stephan Rönigk
Print-ISBN 978-3-446-45072-1 E-Pub-ISBN 978-3-446-45353-1
Verwendete Schriften: SourceSansPro und SourceCodePro (Lizenz) CSS-Version: 1.0
Inhalt
Titelei
Impressum
Inhalt
Widmung
1 Die Programmiersprache Swift
1.1 Die Geschichte von Swift
1.2 Swift-Updates
1.3 Voraussetzungen zur Nutzung von Swift
1.4 Installation von Swift
1.4.1 macOS
1.4.2 Linux
1.5 Xcode
1.5.1 Erstellen von Dateien und Projekten
1.5.2 Der Aufbau von Xcode
1.5.3 Einstellungen
1.6 Playgrounds
1.6.1 Erstellen eines Playgrounds
1.6.2 Aufbau eines Playgrounds
1.6.3 Pages, Sources und Resources
1.6.4 Playground-Formatierungen
1.6.5 Swift Playgrounds-App für das iPad
1.7 Weitere Code-Editoren zur Arbeit mit Swift
1.7.1 Visual Studio Code
1.7.2 Syntra Small
1.7.3 IBM Swift Sandbox
1.8 Swift-Ressourcen und weiterführende Informationen
2 Grundlagen der Programmierung
2.1 Grundlegendes
2.1.1 Swift Standard Library
2.1.2 print
2.1.3 Befehle und Semikolons
2.1.4 Operatoren
2.2 Variablen und Konstanten
2.2.1 Erstellen von Variablen und Konstanten
2.2.2 Variablen und Konstanten in der Konsole ausgeben
2.2.3 Type Annotation und Type Inference
2.2.4 Gleichzeitiges Erstellen und Deklarieren mehrerer Variablen und Konstanten
2.2.5 Namensrichtlinien
2.3 Kommentare
3 Schleifen und Abfragen
3.1 Schleifen
3.1.1 for-in
3.1.2 while
3.1.3 repeat-while
3.2 Abfragen
3.2.1 if
3.2.2 switch
3.2.3 guard
3.3 Control Transfer Statements
3.3.1 Anstoßen eines neuen Schleifendurchlaufs mit continue
3.3.2 Verlassen der kompletten Schleife mit break
3.3.3 Weitere Control Transfer Statements
3.3.4 Labeled Statements
4 Typen in Swift
4.1 Integer
4.2 Fließkommazahlen
4.3 Bool
4.4 String
4.4.1 Erstellen eines Strings
4.4.2 Zusammenfügen von Strings
4.4.3 Character auslesen
4.4.4 Character mittels Index auslesen
4.4.5 Character entfernen und hinzufügen
4.4.6 Anzahl der Character zählen
4.4.7 Präfix und Suffix prüfen
4.4.8 String Interpolation
4.5 Array
4.5.1 Erstellen eines Arrays
4.5.2 Zusammenfügen von Arrays
4.5.3 Inhalte eines Arrays leeren
4.5.4 Prüfen, ob ein Array leer ist
4.5.5 Anzahl der Elemente eines Arrays zählen
4.5.6 Zugriff auf die Elemente eines Arrays
4.5.7 Neue Elemente zu einem Array hinzufügen
4.5.8 Bestehende Elemente aus einem Array entfernen
4.5.9 Bestehende Elemente eines Arrays ersetzen
4.5.10 Alle Elemente eines Arrays auslesen und durchlaufen
4.6 Set
4.6.1 Erstellen eines Sets
4.6.2 Inhalte eines bestehenden Sets leeren
4.6.3 Prüfen, ob ein Set leer ist
4.6.4 Anzahl der Elemente eines Sets zählen
4.6.5 Element zu einem Set hinzufügen
4.6.6 Element aus einem Set entfernen
4.6.7 Prüfen, ob ein bestimmtes Element in einem Set vorhanden ist
4.6.8 Alle Elemente eines Sets auslesen und durchlaufen
4.6.9 Sets miteinander vergleichen
4.6.10 Neue Sets aus bestehenden Sets erstellen
4.7 Dictionary
4.7.1 Erstellen eines Dictionary
4.7.2 Prüfen, ob ein Dictionary leer ist
4.7.3 Anzahl der Schlüssel-Wert-Paare eines Dictionary zählen
4.7.4 Wert zu einem Schlüssel eines Dictionaries auslesen
4.7.5 Neues Schlüssel-Wert-Paar zu Dictionary hinzufügen
4.7.6 Bestehendes Schlüssel-Wert-Paar aus Dictionary entfernen
4.7.7 Bestehendes Schlüssel-Wert-Paar aus Dictionary verändern
4.7.8 Alle Schlüssel-Wert-Paare eines Dictionary auslesen und durchlaufen
4.8 Tuple
4.8.1 Zugriff auf die einzelnen Elemente eines Tuple
4.8.2 Tuple und switch
4.9 Optional
4.9.1 Deklaration eines Optionals
4.9.2 Zugriff auf den Wert eines Optionals
4.9.3 Optional Binding
4.9.4 Implicitly Unwrapped Optional
4.9.5 Optional Chaining
4.9.6 Optional Chaining über mehrere Eigenschaften und Funktionen
4.10 Any und AnyObject
4.11 Type Alias
4.12 Value Type versus Reference Type
4.12.1 Reference Types auf Gleichheit prüfen
5 Funktionen
5.1 Funktionen mit Parametern
5.1.1 Argument Labels und Parameter Names
5.1.2 Default Value für Parameter
5.1.3 Variadic Parameter
5.1.4 In-Out Parameter
5.2 Funktionen mit Rückgabewert
5.3 Function Types
5.3.1 Funktionen als Variablen und Konstanten
5.4 Verschachtelte Funktionen
5.5 Closures
5.5.1 Closures als Parameter von Funktionen
5.5.2 Trailing Closures
5.5.3 Autoclosures
6 Enumerations, Structures und Classes
6.1 Enumerations
6.1.1 Enumerations und switch
6.1.2 Associated Values
6.1.3 Raw Values
6.2 Structures
6.2.1 Erstellen von Structures und Instanzen
6.2.2 Eigenschaften und Funktionen
6.3 Classes
6.3.1 Erstellen von Klassen und Instanzen
6.3.2 Eigenschaften und Funktionen
6.4 Enumeration vs. Structure vs. Class
6.4.1 Gemeinsamkeiten und Unterschiede
6.4.2 Wann nimmt man was?
6.5 self
7 Eigenschaften und Funktionen von Typen
7.1 Properties
7.1.1 Stored Property
7.1.2 Lazy Stored Property
7.1.3 Computed Property
7.1.4 Read-Only Computed Property
7.1.5 Property Observer
7.1.6 Type Property
7.2 Globale und lokale Variablen
7.3 Methoden
7.3.1 Instance Methods
7.3.2 Type Methods
7.4 Subscripts
8 Initialisierung
8.1 Aufgabe der Initialisierung
8.2 Erstellen eigener Initializer
8.3 Initializer Delegation
8.3.1 Initializer Delegation bei Value Types
8.3.2 Initializer Delegation bei Reference Types
8.4 Failable Initializer
8.5 Required Initializer
8.6 Deinitialisierung
9 Vererbung
9.1 Überschreiben von Eigenschaften und Funktionen einer Klasse
9.2 Überschreiben von Eigenschaften und Funktionen einer Klasse verhindern
9.3 Zugriff auf die Superklasse
9.4 Initialisierung und Vererbung
9.4.1 Zwei-Phasen-Initialisierung
9.4.2 Überschreiben von Initializern
9.4.3 Vererbung von Initializern
9.4.4 Required Initializer
10 Speicherverwaltung mit ARC
10.1 Strong Reference Cycles
10.1.1 Weak References
10.1.2 Unowned References
10.1.3 Weak Reference vs. Unowned Reference
11 Weiterführende Sprachmerkmale von Swift
11.1 Nested Types
11.2 Extensions
11.2.1 Computed Properties
11.2.2 Methoden
11.2.3 Initializer
11.2.4 Subscripts
11.2.5 Nested Types
11.3 Protokolle
11.3.1 Deklaration von Eigenschaften und Funktionen
11.3.2 Der Typ eines Protokolls
11.3.3 Protokolle und Extensions
11.3.4 Vererbung in Protokollen
11.3.5 Class-only-Protokolle
11.3.6 Optionale Eigenschaften und Funktionen
11.3.7 Protocol Composition
11.3.8 Delegation
12 Type Checking und Type Casting
12.1 Type Checking mit is
12.2 Type Casting mit as
13 Error Handling
13.1 Deklaration und Feuern eines Fehlers
13.2 Reaktion auf einen Fehler
13.2.1 Mögliche Fehler mittels do-catch auswerten
13.2.2 Mögliche Fehler in Optionals umwandeln
13.2.3 Mögliche Fehler weitergeben
13.2.4 Mögliche Fehler ignorieren
14 Generics
14.1 Generic Functions
14.2 Generic Types
14.3 Type Constraints
14.4 Associated Types
15 Dateien und Interfaces
15.1 Modules und Source Files
15.2 Access Control
15.2.1 Access Level
15.2.2 Explizite und implizite Zuweisung eines Access Levels
15.2.3 Besonderheiten
16 Cocoa, Objective-C und C
16.1 Interoperability
16.1.1 Swift und Cocoa
16.1.2 Swift und Objective-C
16.1.3 Swift und C
16.2 Mix and Match
16.2.1 Mix and Match innerhalb eines App-Targets
16.2.2 Mix and Match innerhalb eines Framework-Targets
16.3 Migration
17 Objektorientierte vs. protokollorientierte Programmierung
17.1 Objektorientierte Programmierung
17.1.1 Praxis
17.1.2 Vor- und Nachteile
17.2 Protokollorientierte Programmierung
17.2.1 Praxis
17.2.2 Vor- und Nachteile
17.3 Fazit
18 Weitere Sprachmerkmale und Profi-Wissen
18.1 Zahlenliterale
18.2 Fortgeschrittene Operatoren
18.2.1 Ternary Conditional Operator
18.2.2 Nil-Coalescing Operator
18.2.3 Unary Minus- und Unary Plus-Operatoren
18.2.4 Bitweise Operatoren
18.2.5 Operator Methods
18.2.6 Eigene Operatoren erstellen
18.3 Option Sets
18.3.1.1 Deklaration eines Option Sets
18.3.1.2 Verwenden eines Option Sets
18.4 Closures
18.4.1 Escaping Closures
18.4.2 Closure Capture List
18.5 Recursive Enumerations
18.6 Optionals im Detail
18.7 Generic Where Clause
18.8 Dynamic Method Lookup
18.9 Weitere Objective-C-Makros
18.9.1 NS_SWIFT_NAME
18.9.2 NS_SWIFT_UNAVAILABLE
Für Ela
‒ auf das was war, und das, was sein wird.
Die Programmiersprache Swift hat sich seit ihrer erstmaligen Vorstellung im Juni 2014 immens weiterentwickelt und dabei mehrere spannende Meilensteine durchlaufen. Nicht nur, dass wir zwischenzeitlich bereits bei Version 3 von Swift angelangt sind, nein, inzwischen ist die Programmiersprache auch Open Source und besitzt eine eigene Online-Plattform unter https://swift.org (siehe Bild 1.1). Dort finden sich ein Blog mit Informationen zur Weiterentwicklung der Sprache, vorgefertigte Downloadpakete, eine Dokumentation, Verweise auf weitere Swift-Projekte und vieles mehr (mehr zu Swift.org erfahren Sie in Abschnitt 1.8, „Swift-Ressourcen und weiterführende Informationen“).
Bild 1.1 Die Plattform Swift.org ist die zentrale Anlaufstelle für die Programmiersprache Swift.
Aufgrund dieser massiven Weiterentwicklungen ist Swift inzwischen mitnichten nur eine Programmiersprache für die Plattformen von Apple. Auf Linux ist es bereits heute möglich, Swift-Code auszuführen, weitere Plattformen werden mit Sicherheit folgen. Dank IBM hat es Swift sogar schon auf die Server und in die Cloud geschafft, woraus sich ebenfalls ganz neue Einsatzgebiete und Möglichkeiten zur Nutzung von Swift für Entwickler ergeben.
Deswegen richtet sich dieses Buch auch nicht ausschließlich an Apple-Entwickler, die mehr über Swift erfahren oder ein deutschsprachiges Referenzwerk dazu besitzen möchten. Vielmehr ist das Buch für all jene geschrieben, die sich für Swift begeistern ‒ egal auf welcher Plattform ‒ und mehr über die Möglichkeiten der Sprache, ihre Syntax und ihre einzigartigen Merkmale erfahren möchten. Es ist ein Buch zu und über Swift und behandelt ausschließlich die Sprache selbst; Informationen zur Entwicklung für spezifische Plattformen wie macOS, iOS oder Linux finden Sie an anderer Stelle, z. B. in meinem Buch „Apps für iOS 10 professionell entwickeln“, das ebenfalls im Hanser Verlag erschienen ist.
1.1 Die Geschichte von SwiftViele Details sind über die genaue Entstehungsgeschichte von Swift nicht bekannt. Was man weiß, ist, dass der Apple-Entwickler Chris Lattner wohl in gewisser Weise als „Vater“ von Swift bezeichnet werden kann. Dieser begann die Entwicklung an Swift im Juli 2010 aus eigenem Antrieb heraus und zunächst im Alleingang. Ab Ende 2011 kamen dann weitere Entwickler dazu, währen das Projekt im Geheimen bei Apple fortgeführt wurde. Das erste Mal zeigte Apple die neue Sprache der Weltöffentlichkeit auf der WWDC (Worldwide Developers Conference) 2014 (siehe Bild 1.2).
Bild 1.2 Auf der WWDC 2014 präsentierte Apple Swift erstmals der Weltöffentlichkeit.
Mit dieser erstmaligen Präsentation von Swift überraschte Apple sowohl Presse als auch Entwickler gleichermaßen. Dabei war die Sprache zunächst ‒ ähnlich wie Objective-C ‒ ausschließlich auf die Plattformen von Apple beschränkt; ein Mac mitsamt der zugehörigen IDE Xcode von Apple waren also Pflicht, wollte man mit Swift Apps für macOS, iOS, watchOS oder tvOS entwickeln. Im Herbst 2014 folgte dann die erste finale Version von Swift, die Apple den Entwicklern zusammen mit einem Update für Xcode zugänglich machte.
Auf der im darauffolgenden Jahr stattgefundenen WWDC 2015 sorgte Apple dann für die nächste große Überraschung. Nicht nur präsentierten sie die neue Version 2 von Swift, sondern gaben auch bekannt, dass Swift noch im gleichen Jahr Open Source werden würde. Dieses Versprechen wurde dann am 03. Dezember 2015 umgesetzt und Apple startete die Plattform Swift.org, um darüber zukünftig alle Weiterentwicklungen und Neuerungen zu Swift zusammenzutragen.
Auf der WWDC 2016 folgte sodann die Vorstellung der neuen Version 3 von Swift, die im Herbst desselben Jahres offiziell veröffentlicht wurde.
1.2 Swift-UpdatesDie Sprache Swift hat in den wenigen Jahren, die sie bisher verfügbar ist, bereits einige große Versionssprünge hingelegt. Gerade am Anfang war das für Swift-Entwickler der ersten Stunde durchaus ein Problem, denn diese Versionssprünge änderten den Code und die Syntax von Swift bisweilen so stark, dass sich Projekte, die mit einer früheren Swift-Version als der aktuellen geschrieben wurden, nicht mehr kompilieren und damit ausführen ließen.
Zwar bietet Apple in seiner Entwicklungsumgebung Xcode einen Assistenten, der Swift-Code einer älteren Version nach der aktuellen migriert, aber meistens konnte auch dieser nicht alle Probleme und Fehler vollumfänglich auflösen, was bedeutete, dass Entwickler ‒ je nach Größe des zugrunde liegenden Projekts ‒ mal mehr, mal weniger Zeit damit verbringen mussten, ihren Code auf die neue Swift-Version zu aktualisieren und entsprechend anzupassen.
Diese Problematik soll ab Version 3 von Swift nun ein Ende haben. Natürlich wird es in Zukunft weitere Versionen der Programmiersprache geben, diese sollen nun aber nicht mehr Code, der in einer älteren Swift-Version geschrieben wurde (solange er mindestens auf Version 3 basiert), gänzlich unbrauchbar und unausführbar machen. Swift 3 stellt somit einen gewissen Meilenstein in dieser noch jungen Programmiersprache dar und stellt nicht zuletzt aus diesem Grund einen idealen Zeitpunkt dar, sich spätestens jetzt einmal ausführlich mit Swift auseinanderzusetzen.
Trotzdem sollen und wollen Sie als Swift-Entwickler natürlich auch up to date bleiben und wissen, wie sich die Sprache weiterentwickelt und welche Neuerungen sie im Laufe der Zeit mit sich bringt. In Abschnitt 1.8, „Swift-Ressourcen und weiterführende Informationen“, am Ende dieses Kapitels stelle ich Ihnen einige wichtige und hilfreiche Ressourcen vor, die Ihnen dabei helfen, Ihr Swift-Know-How stets auf dem neuesten Stand zu halten.
1.3 Voraussetzungen zur Nutzung von SwiftSwift wird aktuell offiziell auf den folgenden Plattformen unterstützt:
macOS
Linux
Auf diesen kann Swift-Code ausgeführt und mithilfe passender Tools geschrieben werden. Unter macOS ist Apples Entwicklungsumgebung Xcode die erste Wahl, wenn es um die Entwicklung mit Swift geht. Unter Linux stellt Apple bisher ausschließlich die sogenannte REPL (Read Eval Print Loop) bereit, die es erlaubt, Swift-Code über das Terminal auszuführen. Darüber hinaus kann Swift-Code noch auf den weiteren Apple-Plattformen iOS, watchOS und tvOS ausgeführt werden.
Wer ernsthaft mit Swift entwickeln möchte, sollte zum jetzigen Zeitpunkt trotz offiziellem Linux-Support nichtsdestoweniger vorzugsweise auf einen Mac mitsamt macOS zurückgreifen. Dank der vollwerten Entwicklungsumgebung Xcode, die Apple kostenlos bereitstellt und in der Swift vollumfänglich integriert ist, ist diese IDE noch immer das Mittel der Wahl für professionelle Software-Entwicklung mit Swift. Die ebenfalls unter Linux zur Verfügung stehende REPL eignet sich ideal für Tests und zum Ausprobieren verschiedener Eigenschaften und Mechanismen der Programmiersprache.
Swift Playgrounds auf dem iPad
Neben den genannten Plattformen ist es auch möglich, Swift-Code auf Apples iPad zu schreiben und auszuführen. Seit Version 10 von iOS ‒ dem Betriebssystem des iPad ‒ bringt dieses nämlich eine kostenlose App namens Swift Playgrounds mit. Darüber ist es möglich ‒ wie der Name bereits andeutet ‒ sogenannte Playgrounds zu erstellen und darin Swift-Code zu schreiben und ausführen zu lassen (siehe Bild 1.3). Die App kompiliert die Eingaben und gibt direkt Feedback über mögliche Syntaxfehler oder andere Probleme.
Bild 1.3 Swift Playgrounds erlaubt das Schreiben und Ausführen von Swift-Code auf dem iPad.
Da die App keine kompletten Projekte, sondern ausschließlich die Playgrounds verwalten kann, ist sie primär dafür gedacht, einzelne Code-Fragmente zu testen oder eine Idee für eine Funktion umzusetzen und zu überprüfen. Dabei kann die App die erzeugten Playgrounds auch mit Xcode auf dem Mac austauschen, damit diese dort weiter genutzt werden können. Mehr zu Playgrounds im Allgemeinen erfahren Sie in Abschnitt 1.6, „Playgrounds“.
Je nachdem, auf welcher Plattform Sie Swift nutzen möchten ‒ macOS oder Linux ‒ verläuft die Installation ein wenig anders und es stehen Ihnen unterschiedliche Tools zur Arbeit mit Swift zur Verfügung (wie im vorherigen Abschnitt 1.3, „Voraussetzungen zur Nutzung von Swift“, beschrieben). Im Folgenden stelle ich Ihnen den Installationsprozess für beide Plattformen im Detail vor.
1.4.1 macOSUm Swift unter macOS nutzen zu können, brauchen Sie im einfachsten Fall nur Folgendes zu tun: Öffnen Sie die App Store-App, suchen Sie nach Xcode und klicken Sie auf die Schaltfläche Laden. Die aktuelle Version von Xcode wird anschließend heruntergeladen und auf Ihrem Mac installiert (siehe Bild 1.4).
Bild 1.4 Laden Sie auf dem Mac einfach die aktuelle Version von Xcode aus dem Mac App Store, um mit der Entwicklung eigener Swift-Anwendungen zu beginnen.
Über den Mac App Store erhalten Sie immer den jeweils aktuellsten Stable-Release von Xcode. Damit können Sie direkt mit der Swift-Programmierung loslegen, allerdings nur für die jeweils aktuell freigegebene Swift-Version. Wenn Sie sich stattdessen für die Entwicklung mit einer sich noch in der Entwicklung befindlichen neuen Version von Swift interessieren, dann führt kein Weg an Swift.org beziehungsweise der Apple Developer-Website (https://developer.apple.com) vorbei; mehr noch, Sie müssen auch Mitglied im kostenpflichtigen Entwicklerprogramm von Apple sein, wenn Sie eine solche Vorabversion von Xcode herunterladen möchten. Ist das der Fall, dann klicken Sie auf der Website von Swift.org auf den Menüpunkt Downloads und scrollen anschließend in den Bereich Previews (siehe Bild 1.5). Dort führt Sie ein Link zur entsprechend aktuellen Xcode-Betaversion direkt weiter auf die Developer-Website von Apple, auf der Sie sich sodann mit Ihrem Entwickler-Account authentifizieren. Anschließend können Sie diese Vorabversion von Xcode herunterladen und direkt auf Ihrem Mac installieren, indem Sie das heruntergeladene Archiv per Doppelklick entpacken und anschließend die Xcode-App in den Ordner Programme verschieben.
Bild 1.5 Im Previews-Bereich auf Swift.org finden Sie die aktuellste Vorabversion von Xcode mitsamt der neuesten Swift-Preview.
Mehr zur grundlegenden Arbeit mit Xcode erfahren Sie in Abschnitt 1.5, „Xcode“.
1.4.2 LinuxWenn Sie Swift unter Linux installieren möchten, besteht Ihr erster Gang in Richtung Swift.org. Dort finden Sie nach Klick auf Downloads verschiedene vorgefertigte Downloadpakete von Swift für Linux. Die Xcode-Downloads können Sie dabei ignorieren, da Xcode ausschließlich unter macOS zur Verfügung steht (siehe auch den vorherigen Abschnitt 1.4.1, „macOS“).
Die verfügbaren Downloads sind in verschiedene Bereiche unterteilt, die interessantesten sind in der Regel Releases und Previews. Unter Releases haben Sie Zugriff auf die jeweils aktuell freigegebene Version von Swift, während Sie unter Previews fertige Downloadpakete von Vorabversionen herunterladen können.
Ganz gleich, für welche Version von Swift Sie sich entscheiden, setzen sich die fertigen Downloadpakete für Linux immer aus zwei Bestandteilen zusammen, die beide separat heruntergeladen werden müssen:
Binary
Signature
Bei der Binary handelt es sich um eine bereits kompilierte Version von Swift für die jeweilige Linux-Distribution. Generell kann Swift auch auf anderen Linux-Distributionen installiert und ausgeführt werden, die nicht explizit auf Swift.org als fertige Binary angeboten werden, dann muss man sich allerdings selbst um einen passenden Port aus den Quelldateien kümmern beziehungsweise nach anderen (seriösen) Quellen dazu im Internet suchen. Die fertige Binary können Sie per Klick auf den Namen der gewünschten Linux-Distribution herunterladen.
Ebenso herunterladen müssen Sie die zugehörige Signatur, die Ihnen als Signature-Link direkt unterhalb des Binary-Links der jeweiligen Distribution zum Download angeboten wird (siehe Bild 1.6).
Bild 1.6 Unter Linux müssen Sie sowohl die eigentliche Swift-Binary als auch die Signatur über beide Links herunterladen.
Sind beide Downloads abgeschlossen, kann die eigentliche Installation von Swift unter Linux beginnen. Stellen Sie zunächst sicher, alle benötigten Abhängigkeiten und Programme heruntergeladen und installiert zu haben. Führen Sie dazu den folgenden Befehl im Terminal aus:
Wenn Sie das allererste Mal Swift unter Linux herunterladen und installieren, müssen Sie auch die passenden PGP Keys unter Linux hinzufügen. Geben Sie dazu den nachfolgenden Befehl in das Terminal ein und führen Sie diesen anschließend aus:
Ebenso benötigen Sie ‒ zur Überprüfung der Aktualität und Echtheit der heruntergeladenen Pakete ‒ den passenden Public Key, der für das Signieren verwendet wurde. Diesen können Sie über den folgenden Terminal-Befehl herunterladen und importieren:
Bevor es nun an die eigentliche Installation geht, sollten Sie in jedem Fall die Echtheit der heruntergeladenen Signatur überprüfen. Dazu laden Sie zunächst eine Liste der bereits zurückgezogenen beziehungsweise aufgehobenen Zertifikate herunter, gegen die Sie die Signatur im zweiten Schritt dann prüfen können. Führen Sie dazu zunächst den folgenden Befehl im Terminal aus:
Ist das erledigt, können Sie die Echtheit und Aktualität Ihrer heruntergeladenen Signatur mit dem folgenden Befehl überprüfen:
<VERSION> und <PLATTFORM> sind dabei durch die entsprechenden Informationen zu ersetzen, die der von Ihnen heruntergeladenen Binary und Signature für Linux entsprechen, beispielsweise wie folgt:
Wundern Sie sich nicht, falls Sie eine Warnung mit dem Text This key is not certified with a trusted signature! erhalten; das ist in Ordnung. Sollte aber die Verifizierung gänzlich fehlschlagen und Sie eine Meldung BAD Signature erhalten, sollten Sie die heruntergeladene Binary keinesfalls verwenden und überprüfen, was beim Download schiefgegangen ist beziehungsweise aus welcher Quelle Sie das Paket bezogen haben.
Nach all diesen grundlegenden Vorbereitungen geht es nun endlich an die eigentliche Swift-Binary. Entpacken Sie dazu zunächst das heruntergeladene Paket mit dem folgenden Terminal-Befehl:
Auch hier gilt es, <VERSION> und <PLATTFORM> durch die passenden Informationen aus dem von Ihnen heruntergeladenen Paket zu ersetzen, beispielsweise wie folgt:
Zu guter Letzt sollten Sie noch die Nutzung von Swift als PATH setzen, um anschließend die Nutzung von Swift einfach mittels des Terminal-Befehls swift starten zu können. Dazu existiert innerhalb des eben entpackten Archivs ein Ordner usr und darin wiederum ein Ordner bin. Den Pfad zu diesem Ordner müssen Sie exportieren und der PATH-Variablen hinzufügen, um anschließend wie beschrieben Swift mittels des Befehls swift im Terminal ausführen und starten zu können. Im Folgenden sehen Sie den entsprechenden Befehl, mit dem Sie dieses gewünschte Verhalten umsetzen:
<PFAD ZU /USR/BIN> bezieht sich auf den genannten Verweis des entpackten Swift-Archivs und dessen bin-Ordner.
Wenn Sie nun im Terminal den Befehl swift eingeben, startet die REPL und Sie können damit beginnen, Swift-Code zu schreiben und auszuführen (siehe Bild 1.7).
Bild 1.7 Nach der erfolgreichen Installation kann Swift mittels des Befehls swift unter Linux im Terminal ausgeführt werden.
Unter macOS ist Xcode die Entwicklungsumgebung der Wahl, wenn es um die Programmierung mit Swift geht. Diese von Apple entwickelte IDE (Integrated Development Environment) bringt alles mit, was Sie brauchen, um eigenen Swift-Code zu schreiben und auszuführen (siehe Bild 1.8). Dabei liegt der Schwerpunkt von Xcode natürlich vorrangig in der Entwicklung von Apps für Apples Plattformen macOS, iOS, watchOS und tvOS, aber Sie können auch unabhängig davon in Swift programmieren und die Sprache für Ihre Projekte nutzen.
Bild 1.8 Xcode ist Apples Entwicklungsumgebung für die Programmierung von Apps mit Swift.
In diesem Abschnitt möchte ich Ihnen eine grobe Einführung in Xcode geben und Ihnen zeigen, wie die Entwicklungsumgebung aufgebaut ist, wie Sie neue Projekte und Code-Dateien erstellen und welche Möglichkeiten Ihnen zur Individualisierung zur Verfügung stehen.
1.5.1 Erstellen von Dateien und ProjektenNachdem Sie Xcode aus dem App Store heruntergeladen und installiert (oder eine Vorabversion aus dem Apple Developer Portal bezogen) haben und die App starten, werden Sie mit dem Starfenster von Xcode begrüßt (siehe Bild 1.9). Es bietet Ihnen Zugriff auf die zuletzt geöffneten Dateien und Projekte (sofern vorhanden) und erlaubt Ihnen das Erstellen eines neuen Projekts oder Playgrounds (mehr zu Playgrounds erfahren Sie in Abschnitt 1.6, „Playgrounds“). Auch können Sie ein Projekt, das in einem entfernten Versionsverwaltungssystem existiert, direkt auschecken und die Arbeit daran beginnen.
Bild 1.9 Über das Startfenster von Xcode erstellen Sie ein neues Projekt oder greifen direkt auf bereits existierende Dateien und Projekte zu.
Neues Xcode-Projekt erstellen
Wenn Sie als Apple-Entwickler mit Swift arbeiten und für eine der verfügbaren Apple-Plattformen Apps entwickeln möchten, dann sind die Xcode-Projekte die richtige Anlaufstelle für Sie. Wenn Sie vom Startfenster aus auf die Schaltfläche Create a new Xcode project drücken beziehungsweise über das Xcode-Menü File → New → Project… auswählen, öffnet sich eine Template-Ansicht, in der Sie zwischen den verschiedenen Apple-Plattformen und unterschiedlichen Vorlagen zum Starten eines neuen Projekts wählen können (siehe Bild 1.10).
Bild 1.10 Sie können beim Erstellen eines neuen Xcode-Projekts zwischen den verschiedenen Apple-Plattformen und unterschiedlichen Vorlagen wählen.
Bild 1.11 Ein neu erstelltes und geöffnetes Xcode-Projekt.
Im oberen Bereich wählen Sie die Plattform, unter der Ihre App lauffähig sein soll (iOS, watchOS, tvOS oder macOS). Alternativ finden Sie unter Cross-platform Vorlagen zur Unterstützung mehrerer Plattformen und auch eine komplett leere Vorlage (es wird also ein Projekt ohne jegliche Dateien erstellt). Haben Sie sich so für eine zu Ihren Zwecken passende Vorlage entschieden, geht's per Klick auf Next weiter. In dem sich öffnenden Fenster legen Sie dann spezifische Einstellungen für Ihr neues Projekt fest, die sich je nach gewählter Vorlage voneinander unterscheiden können. Ein weiterer Klick auf Next fragt Sie dann nach dem gewünschten Speicherort des Projekts auf der Festplatte Ihres Mac. Per abschließendem Klick auf die Schaltfläche Create wird das neue Xcode-Projekt erstellt und direkt geöffnet (siehe Bild 1.11).
Neue Swift-Datei erstellen
Swift-Code wird typischerweise innerhalb von eigenen Swift-Dateien erstellt und gespeichert; diese enden auf die Dateiendung .swift. In Xcode erstellen Sie solch eine neue Code-Datei über das Xcode-Menü durch Auswahl von File → New → File…. Daraufhin öffnet sich ein Fenster mit verschiedenen Dateivorlagen, die Xcode erstellen kann und aus denen Sie wählen können (siehe Bild 1.12).
Bild 1.12 Xcode bietet verschiedene Vorlagen zum Erstellen einer neuen Datei.
Am oberen Bildschirmrand können Sie zunächst wieder die Plattform wählen, für die Sie eine neue Datei erstellen möchten (iOS, watchOS, tvOS oder macOS). Je nach Auswahl bietet Xcode Ihnen anschließend verschiedene Dateivorlagen an. In der Regel sind diese meist plattformspezifisch und eng an die Entwicklung für die jeweils ausgewählte Plattform gekoppelt. Eine Ausnahme bildet hierbei die Vorlage Swift File, die bei allen vier verfügbaren Plattformen gleichermaßen vorhanden ist und dazu dient, eine leere neue Swift-Datei zu erstellen. Nach Auswahl dieser Vorlage und Klick auf Next brauchen Sie nur noch den gewünschten Dateinamen einzugeben und einen Speicherort auszuwählen; ein anschließender Klick auf Create erstellt die neue Swift-Datei (siehe Bild 1.13).
Bild 1.13 Eine mit Xcode neu erstellte Swift-Datei
Erstellen Sie auf die gezeigte Art und Weise eine neue Datei bei geöffnetem Xcode-Projekt, so wird diese Datei automatisch diesem Projekt hinzugefügt. Erstellen Sie hingegen solch eine neue Swift-Datei beispielsweise direkt nach dem Starten von Xcode (ohne, dass dabei ein Xcode-Projekt geöffnet ist), so können Sie darüber eine einfache Swift-Datei erstellen, die für sich selbst steht und keinem spezifischen Projekt zugeordnet ist (beispielsweise zum Testen von projektunabhängigem Code oder einfach zum Experimentieren).
1.5.2 Der Aufbau von XcodeDas Projektfenster von Xcode unterteilt sich in insgesamt fünf Bereiche (siehe Bild 1.14):
Toolbar
Navigator Area
Editor Area
Utilities Area
Debug Area
Bild 1.14 Das Xcode-Projektfenster unterteilt sich in insgesamt fünf verschiedene Bereiche.
In den folgenden Abschnitten stelle ich Ihnen all diese Bereiche vor und erläutere, was es mit ihnen auf sich hat, wofür sie gut sind, und welche Aufgaben sie erfüllen.
Toolbar
Die Toolbar wird am oberen Rand des Fensters angezeigt und zieht sich über die komplette Fensterbreite (siehe Bild 1.15).
Bild 1.15 Die Toolbar von Xcode erstreckt sich am oberen Rand des Projektfensters.
Am linken Rand der Toolbar befinden sich Schaltflächen zum Ausführen und Starten eines App-Projekts (siehe Bild 1.16). Außerdem können Sie hier beispielsweise bei der Entwicklung für iOS zwischen verschiedenen iPhone- und iPad-Simulatoren wählen, auf denen Ihre App ausgeführt und gestartet werden soll.
Bild 1.16 Die Schaltflächen im linken Bereich der Toolbar erlauben das Ausführen von App-Projekten.
Im mittleren Bereich der Toolbar befindet sich eine Statuszeile, die Sie über verschiedene Aktionen innerhalb von Xcode informiert (siehe Bild 1.17). Dazu gehören im Hintergrund laufende Downloads oder das Kompilieren einer App.
Bild 1.17 Die Statusbar informiert über von Xcode ausgeführte Aktionen.
Im rechten Bereich schließlich finden sich verschiedene Schaltflächen zum Anpassen von Xcode. Die erste Dreierreihe bezieht sich dabei ausschließlich auf die sogenannte Editor Area in der Mitte des Xcode-Projektfensters (siehe Bild 1.18). Darüber können Sie die Ansicht und die Darstellung dieses Bereiches verändern und anpassen. Die letzten drei Schaltflächen dienen zum Ein- und Ausblenden der Navigator, Debug und Utilities Area (siehe Bild 1.19).
Bild 1.18 Diese Schaltflächen erlauben das Anpassen der Editor Area von Xcode.
Bild 1.19 Über diese Schaltflächen können die Navigator, Debug und Utilties Area in Xcode ein- und ausgeblendet werden.
Navigator Area
Über die Navigator Area haben Sie Zugriff auf die Dateien eines Xcode-Projekts (siehe Bild 1.20). Es unterteilt sich in mehrere separate Bereiche, die über die Schaltflächen am oberen Rand der Navigator Area umgeschaltet und gewechselt werden können. Die Standardansicht ist der sogenannte Project Navigator, der alle Dateien eines Projekts in einer Ordnerstruktur aufführt. Sie können darüber die Datei auswählen, deren Inhalt Sie in der Editor Area betrachten und bearbeiten wollen, sowie neue Dateien und Ordner zum Projekt hinzufügen.
Bild 1.20 In der Navigator Area haben Sie Zugriff auf die Dateien eines Xcode-Projekts.
Über die Schaltflächen am oberen Rand der Navigator Area lässt sich die Darstellung dynamisch anpassen. So können Sie sich beispielsweise alternativ alle Klassen Ihres Projekts mit all ihren Eigenschaften anzeigen lassen oder die Inhalte ihrer Dateien durchsuchen. Auch Warnungen oder Fehler, die im Zusammenspiel mit einem Projekt auftreten, werden in der Navigator Area aufgeführt.
Editor Area
Die Editor Area ist das Herzstück von Xcode. Sie nimmt generell den größten Bereich des Projektfensters ein und kümmert sich um die Darstellung der in der Navigator Area ausgewählten Datei. Dabei wechselt die Editor Area auch dynamisch ihr Aussehen, abhängig davon, welche Art von Datei ausgewählt wurde (siehe Bild 1.21). Wird so beispielsweise eine Swift-Datei ausgewählt, zeigt die Editor Area den Quellcode an. Wählt man hingegen eine User Interface-Datei zur Bearbeitung einer grafischen Oberfläche, stellt die Editor Area auch eine entsprechend dafür optimierte Ansicht bereit.
Bild 1.21 Die Editor Area stellt den größten Bereich innerhalb des Xcode-Projektfensters dar und passt sich dynamisch anhand der ausgewählten Quelldatei an.
Innerhalb der Editor Area findet die eigentliche Arbeit in Xcode-Projekten statt. Hier wird der Code geschrieben und das Aussehen sowie die Funktionsweise einer App bestimmt.
Utilities Area
Die Utilities Area wird am rechten Rand des Xcode-Fensters angezeigt (sofern sie über die entsprechende Schaltfläche in der Toolbar aktiviert ist) und gibt verschiedene Informationen zum Projekt selbst sowie zur ausgewählten Datei und darin ausgewählten Elementen wieder (siehe Bild 1.22). Insbesondere bei der Bearbeitung grafischer Benutzeroberflächen spielt die Utilities Area eine essenzielle Rolle, da darüber verschiedene Einstellungen für Ansichten gesetzt und konfiguriert werden können (beispielsweise die Farbe eines Texts oder die Größe eines Bildes). Dabei unterteilt sich die Utilities Area ‒ genau wie die Navigator Area ‒ in verschiedene Bereiche, die über Schaltflächen am oberen Rand durchgewechselt werden können. Welche Schaltflächen hier angezeigt werden, hängt immer von der aktuell ausgewählten Datei sowie dem in der Editor Area ausgewählten Element innerhalb dieser Datei ab.
Bild 1.22 Die Utilities Area passt sich dynamisch anhand der ausgewählten Datei an.
Auf diese Art und Weise stellt die Utilities Area verschiedene unterschiedliche Aktionen bereit, um die Arbeit in Xcode-Projekten zu erleichtern. Sie verfügt zusätzlich noch über eine weitere Ansicht am unteren Rand des Fensters, die per Ziehen mit der Maus nach oben oder unten ein- beziehungsweise ausgeblendet werden kann (siehe Bild 1.23). Dort finden sich verschiedene Vorlagen beispielsweise für das Erstellen von Klassen oder Methoden. Auch befindet sich dort eine Library mit verschiedenen UI-Elementen, die bei der Bearbeitung einer grafischen Oberfläche in die Editor Area gezogen werden kann. Auf diese Weise können per Drag & Drop eigene Ansichten erstellt werden.
Bild 1.23 Der untere Bereich der Utilities Area kann separat ein- und ausgeblendet werden und enthält verschiedene Vorlagen sowohl für Code als auch für grafische Oberflächen.
Debug Area
Die Debug Area übernimmt ‒ wie der Name bereits andeutet ‒ alle Aufgaben des Debuggens in Xcode (siehe Bild 1.24). Sie unterteilt sich in zwei Bereiche, die über zwei zugehörige Schaltflächen am unteren rechten Rand der Debug Area separat ein- und ausgeblendet werden können: die Variables View und die Konsole.
Bild 1.24 Die Debug Area unterteilt sich in zwei Bereiche zum Debuggen eines Programms: die Variables View und die Konsole.
Dabei gibt die Variables View Aufschluss über alle aktiven und relevanten Variablen, Konstanten und Parameter, sobald ein mit Xcode ausgeführtes Programm angehalten wird (beispielsweise aufgrund eines kritischen Fehlers oder eines selbst gesetzten Breakpoints). So können die Werte von Variablen zu verschiedenen Zeitpunkten ausgelesen und überprüft werden, was bei einer möglichen Fehler- oder Optimierungssuche immens hilfreich sein kann.
Die Konsole wiederum dient zwei Zwecken: einerseits werden darin Konsolenausgaben angezeigt, die vom ausgeführten Programm gesetzt werden. Andererseits erlaubt die Konsole auch das Ausführen von Befehlen, um so entweder weitere Informationen zum aktuell ausgeführten Programm auszulesen oder dieses sogar zur Laufzeit zu manipulieren (beispielsweise durch Änderung des Werts einer Variablen).
1.5.3 EinstellungenDie Einstellungen von Xcode können über das Menü via Xcode → Preferences… aufgerufen werden (siehe Bild 1.25). Darüber stehen verschiedenste Optionen zur Verfügung, um Xcode an die eigenen Bedürfnisse anzupassen. Es können zum Beispiel ein eigenes Farblayout für den Editor festgelegt sowie Tastaturkürzel erstellt und bearbeitet werden. Auch können über die Einstellungen verschiedene zusätzliche Simulatoren für die Entwicklung für die verschiedenen Apple-Plattformen heruntergeladen werden.
Bild 1.25 Xcode kann über die Einstellungen an die eigenen Bedürfnisse angepasst werden.
Bei Playgrounds handelt es sich um ein spezielles Dateiformat zum Schreiben und Ausführen von Swift-Code. Aktuell lassen sich Playgrounds sowohl mit Xcode als auch mit der iPad-App Swift Playgrounds erstellen und verwenden (siehe Bild 1.26).
Bild 1.26 Playgrounds erlauben das Ausprobieren und Dokumentieren von Swift-Code.
Wie der Name bereits andeutet, sind Playgrounds auf das Ausprobieren von und Experimentieren mit Swift ausgelegt. Dabei wird der in Playgrounds eingegebene Code umgehend kompiliert und das daraus entstehende Ergebnis angezeigt. Auch bringen Playgrounds sehr gute Möglichkeiten zur Dokumentation mit. So lassen sich schnell und leicht Überschriften verschiedener Ebenen formatieren und Aufzählungen umsetzen, die parallel zum geschriebenen Code angezeigt werden.
Mit diesen Eigenschaften eignen sich Playgrounds auch ideal zum Einstieg in die Swift-Entwicklung und zum Ausprobieren eigener Ideen. Auch beim Durcharbeiten dieses Buches sind Playgrounds ein geeignetes Mittel, um die Inhalte der einzelnen Kapitel und Abschnitte möglichst schnell praktisch anzuwenden und mit ihnen zu experimentieren. Darum stelle ich in diesem Abschnitt Playgrounds einmal mit ihrer grundlegenden Funktionalität vor. Dabei beschränke ich mich auf die Arbeit mit Playgrounds in Xcode, da diese umfangreicher und ausgereifter sind und deutlich mehr Möglichkeiten bieten, als das bei der Swift Playgrounds-App für das iPad der Fall ist.
1.6.1 Erstellen eines PlaygroundsEin neuer Playground kann entweder direkt aus dem Startfenster von Xcode heraus ober über das Menü über File → New → Playground… erstellt werden (siehe Bild 1.27). Anschließend öffnet sich ein neues Fenster, in dem Sie den gewünschten Namen für den neu zu erstellenden Playground festlegen sowie aus dem Drop-down-Menü Platform eine der verfügbaren Plattformen auswählen (siehe Bild 1.28). Durch letztere Auswahl werden bereits
Bild 1.27 Ein neuer Playground kann direkt aus dem Startfenster von Xcode heraus erstellt werden.
Bild 1.28 Es reicht die Eingabe eines Namens sowie die Auswahl einer Plattform, um einen neuen Playground in Xcode zu erstellen.
erste Frameworks importiert, die für die Entwicklung von Apps für die jeweilige Plattform essenziell sind (was aber nicht bedeutet, dass Sie diese Frameworks auch benutzen müssen; Sie können auch stattdessen ganz grundlegenden Swift-Code schreiben und ausführen, der unabhängig von der gewählten Plattform ist, wodurch die Auswahl in diesem Fall letzten Endes irrelevant ist).
Nach einem anschließenden Klick auf Next fragt Xcode nach dem Speicherort der neuen Playground-Datei, ein weiterer Klick auf Create erstellt diese und öffnet sie direkt (siehe Bild 1.29).
Bild 1.29 Ein neu erstellter Playground in Xcode
Der grundlegende Aufbau eines Playgrounds ist zu vergleichen mit dem eines Xcode-Projekts, gestaltet sich aber ein wenig kompakter, schlanker und übersichtlicher. Im Folgenden stelle ich Ihnen alle Elemente des Playground-Fensters im Detail vor.
Editor
Die Standardansicht, die auch zu sehen ist, wenn ein neuer Playground erstellt wurde, zeigt lediglich das Editor-Fenster an, welches sich bei Playgrounds in zwei Bereiche teilt. Den größten Raum nimmt die weiße Fläche des Editors ein, in dem der eigentliche Swift-Code geschrieben wird. Daneben befindet sich auf der rechten Seite ein leicht gräulicher Bereich, der bei der Arbeit mit Xcode exklusiv in Playgrounds zur Verfügung steht und die Playgrounds auch so besonders macht. Dort nämlich werden direkt Informationen und Ausgaben zu dem von Ihnen erstellten Code angezeigt. Sie sehen sofort, wie oft beispielsweise eine Schleife durchlaufen wurde oder welchen Wert eine Variable besitzt. In dem Standardcode, der Teil eines jeden neu erstellten Playgrounds ist, ist das bereits sehr gut zu sehen: Dort wird eine Variable str erstellt und ihr der String "Hello, playground" zugewiesen. Genau dieser String ‒ der Inhalt der Variablen str zu diesem Zeitpunkt ‒ wird auch direkt in eben dem grauen Bereich auf der rechten Seite angezeigt (siehe Bild 1.30).
Bild 1.30 Im rechten Bereich des Playground-Editors werden direkt Ausgaben und Informationen zum eingegebenen Swift-Code angezeigt.
Wenn Sie nun mit der Maus über solch einen Output im grauen Bereich des Editors fahren, erscheinen zwei Schaltflächen am rechten Rand neben dem jeweiligen Eintrag (siehe Bild 1.31). Bei der linken der beiden handelt es sich um die sogenannte Quick Look-Ansicht. Ein Klick darauf öffnet eine Vorschau für das jeweilige Element. Im Falle des Strings zeigt Quick Look einfach noch einmal den reinen Text (ohne Anführungszeichen) an. Quick Look kann aber noch mehr. Es kann beispielsweise konkrete Informationen zu Farben zurückliefern oder das einer Variablen zugewiesene Bild direkt anzeigen (siehe Bild 1.32). Damit liefert Quick Look bisweilen mehr Informationen zu einem Element als das, was im rechten grauen Bereich des Editors angezeigt wird. Welche Informationen in welcher Form zu einem Element mittels Quick Look angezeigt und ausgegeben werden, ist von Typ zu Typ unterschiedlich.
Bild 1.31 Bei einem Mouseover über ein Element im rechten grauen Editorbereich erscheinen zwei zusätzliche Schaltflächen.
Bild 1.32 Ein Klick auf die Quick Look-Schaltfläche liefert eine grafische Vorschau zum zugehörigen Element.
Neben der Quick Look-Schaltfläche befindet sich ein weiterer Button mit dem Titel Show Result. Dieser bindet die eben vorgestellte Quick Look-Ansicht direkt in den Quelltext des Playgrounds unterhalb des zugehörigen Elements ein (siehe Bild 1.33), ein weiterer Klick auf die Schaltfläche entfernt die Quick Look-Ansicht wieder. Der große Vorteil dieses direkten Einbindens von Quick Look liegt darin, dass die Quick Look-Ansicht selbst nun auch bei jedem Kompilieren des Playgrounds aktualisiert wird. Somit sehen Sie innerhalb des Playgrounds sofort, inwieweit sich ein bestimmtes Element verändert hat und welchen Wert es besitzt.
Bild 1.33 Die Quick Look-Vorschau kann direkt unterhalb des zugehörigen Elements in den Quellcode des Playgrounds eingebunden werden.
Konsole und Codeausführung
Am unteren linken Bildschirmrand des Editors finden sich zwei Schaltflächen. Mit der linken lässt sich die Konsole von Xcode ein- und ausblenden. Sie wird immer dann automatisch eingeblendet, sobald der vom Playground ausgeführte Code etwas in der Konsole ausgibt. Daneben befindet sich ein Run-Button zum Ausführen des Playground-Codes. Wird er betätigt, wird der gesamte Code des Playgrounds kompiliert. Standardmäßig geschieht das automatisch nach jeder Codeänderung, Sie können dieses Verhalten aber ändern, in dem Sie längere Zeit den Play-Button gedrückt halten. Dann öffnet sich ein Pop-up, in dem Sie zwischen den Optionen Automatically Run und Manually Run wählen können (standardmäßig ist Automatically Run aktiv, siehe Bild 1.34). Wenn Sie hier Manually Run auswählen, dann wird der Code des Playgrounds nur dann ausgeführt, wenn Sie explizit den Play-Button per einfachem Klick betätigen. Besonders auf leistungsschwächeren Rechnern mag diese Option sinnvoll sein, da das schier ununterbrochene Ausführen des Codes durchaus einige Ressourcen des Mac beanspruchen kann.
Bild 1.34 Sie können das ständige automatische Ausführen des Playground-Codes auch deaktivieren.
Toolbar
Am oberen Rand des Fensters befindet sich die Toolbar. Diese informiert über eine Statusleiste in der Mitte über die aktuell von Xcode ausgeführten Aktionen wie beispielsweise den Start eines Simulators im Hintergrund, das Ausführen des Playground-Codes oder das Herunterladen zusätzlicher Inhalte. Auch werden Ihnen dort Warnungen und Fehler angezeigt, sollte es im Code Probleme geben (siehe Bild 1.35).
Bild 1.35 Die Statusbar informiert über aktuelle Xcode-Aktivitäten und macht auf etwaige Fehler und Probleme im Code aufmerksam.
Am rechten Rand der Toolbar finden sich dann noch die bereits aus Xcode-Projekten bekannten Schaltflächen zum Anpassen des Editors (erste Dreierreihe) sowie zum Ein- und Ausblenden einzelner Bereiche (letzte Dreierreihe, siehe Bild 1.36).
Bild 1.36 Die Playground-Ansicht kann über die Schaltflächen am oberen rechten Bildschirmrand angepasst werden.
So können Sie mithilfe der letzten drei Schaltflächen eine Übersicht der Dateien des Playgrounds, die bereits bekannte Konsole sowie die Utilities Area einblenden (siehe Bild 1.37).
Bild 1.37 Das Playground-Fenster kann um insgesamt drei Bereiche ergänzt werden.
Navigator Area
Die Navigator Area lässt sich mithilfe der eben gezeigten Schaltflächen am linken Bildschirmrand des Playgrounds ein- und ausblenden. Sie gewährt Zugriff auf die Dateien des Playgrounds, informiert im Detail über Fehler und Warnungen im Code und erlaubt das Durchsuchen des Quelltexts. Dazu verfügt die Navigator Area am oberen Rand über vier Schaltflächen, über die in die verschiedenen Abschnitte gewechselt werden kann (siehe Bild 1.38).
Bild 1.38 Über die Navigator Area haben Sie Zugriff auf die Dateien eines Playgrounds.
Mehr zum Erstellen und Hinzufügen von Dateien zu einem Playground erfahren Sie in Abschnitt 1.6.3, „Pages, Sources und Resources“.
Utilities Area
Sie können die Utilities Area über die entsprechende Schaltfläche aus der Toolbar dynamisch ein- und ausblenden. Sie liefert Informationen über die eigentliche Playground-Datei und bietet einen Schnellzugriff auf die Dokumentation von Apple nach Auswahl eines bestimmten Typs oder einer Funktion im Quellcode (siehe Bild 1.39).
Bild 1.39 Die Utilities Area liefert Informationen zum Playground und einen Schnellzugriff auf die Dokumentation von Apple.
Ein Playground setzt sich immer aus einer sogenannten Page zusammen. Das ist letzten Endes eine spezielle Datei, die von Xcode gelesen und bearbeitet werden kann und die direkte Ausgaben des eigenen Codes im rechten Bereich des Editors erlaubt (wie wir im vorherigen Abschnitt 1.6.2, „Aufbau eines Playgrounds“, gesehen haben). Jede Page verfügt über zwei Unterordner, um weitere Dateien zu verwalten:
Sources
Resources
Dem Sources-Ordner können reine Quellcode-Dateien hinzugefügt werden, die für den Playground benötigt werden. Typischerweise handelt es sich dabei um einfache Swift-Dateien mit der Dateiendung .swift. Beispielsweise haben Sie bereits zuvor an einer anderen Stelle Code geschrieben, den Sie nun für eine bestimmte Funktion oder für Testzwecke in einem Playground verwenden möchten. Dann können Sie ‒ anstatt den gesamten entsprechenden Code in die Page des Playgrounds zu kopieren ‒ die entsprechenden Swift-Dateien einfach als Quellcode-Dateien dem Sources-Ordner der Playground-Page hinzufügen.
Selbiges gilt für Resources, wobei dieser Ordner ‒ wie der Name bereits andeutet ‒ für Dateien wie Bilder oder Videos gedacht ist. Sollten Sie also für Ihren Playground zusätzliche Dateien abseits des reinen Quellcodes benötigen, können Sie diese in den Resources-Ordner der zugehörigen Page einbinden.
Um Zugriff auf die beiden genannten Ordner zu erhalten, müssen Sie zunächst über die zugehörige Schaltfläche in der Toolbar die Navigator Area einblenden. Dann sehen Sie innerhalb der Navigator Area bereits die Page des Playgrounds (diese wird an oberster Stelle angezeigt und trägt den gleichen Titel wie der Playground) sowie die beiden Unterordner Sources und Resources (siehe Bild 1.40). Sollten Sie letztere nicht sehen, müssen Sie sehr wahrscheinlich die Page mittels der vorangestellten Pfeilschaltfläche „aufklappen“, damit die Unterordner angezeigt werden.
Bild 1.40 Die Navigator Area zeigt die zugrunde liegende Page mitsamt Unterordnern des Playgrounds an.
Möchten Sie nun ein Source-File oder eine Resource zu einer Playground-Page hinzufügen, wählen Sie zuvor den gewünschten Ordner, dem Sie eine Datei hinzufügen möchten, per Linksklick aus und klicken anschließend auf die Plus-Schaltfläche am unteren linken Rand der Navigator Area. Dort erscheint dann ein Pop-up-Menü mit verschiedenen Auswahloptionen (siehe Bild 1.41).
Bild 1.41 Über die Plus-Schaltfläche am unteren linken Rand der Navigator Area können einem Playground neue Dateien hinzugefügt werden.
Der erste Punkt File… öffnet die Template-Ansicht von Xcode zum Erstellen einer neuen Datei (siehe dazu auch den Abschnitt 1.5.1, „Erstellen von Dateien und Projekten“), darüber hinaus können Sie auch bereits vorhandene Dateien mittels der letzten Schaltfläche Add Files to "<NAME DES PLAYGROUNDS>"… von Ihrem Mac auswählen und so zu Ihrem Playground hinzufügen.
Ebenso haben Sie die Möglichkeit, Ihren Playground mithilfe der Schaltfläche New Page um weitere Pages zu erweitern. In diesem Fall erstellt Xcode beim erstmaligen Betätigen der Schaltfläche zwei neue Pages unterhalb der obersten Page, die den Namen des Playgrounds trägt, und verschiebt dabei den Inhalt dieser obersten Page in eine der beiden neu erstellten (siehe Bild 1.42). Damit wird diese oberste Page zu einer Art übergeordnetem Element, das selbst direkt keinen Inhalt mehr besitzt, sondern diesen stattdessen über seine Unterseiten verwaltet. Anschließend können Sie die neu erstellten Pages noch umbenennen, indem Sie sie erst einmal mittels Linksklick selektieren, kurz warten und anschließend erneut mit der linken Maustaste anklicken.
Bild 1.42 Beim erstmaligen Hinzufügen einer neuen Page werden direkt zwei Pages unterhalb des obersten Elements erstellt.
Sie können mit den beiden neu erstellten Pages nun genauso arbeiten wie zuvor mit der eigentlichen Playground-Page und können darin alle bekannten Vorteile von Playgrounds nutzen. Mehrere Pages sind vor allen Dingen dann sinnvoll, wenn Sie sehr viel Code in Ihrem Playground schreiben, um diesen besser zu strukturieren und den Playground selbst ein wenig übersichtlicher zu gestalten. Dabei können Sie Ihren Playground auch auf die gezeigte Art und Weise um weitere Pages ergänzen und so ganz Ihren Bedürfnissen anpassen.
Darüber hinaus besitzt aber auch jede neu erzeugte Page ebenfalls für sich genommen noch einmal die beiden genannten Unterordner Sources und Resources. Diese dienen dazu, bestimmte Dateien dort einzufügen, die nur im Zusammenhang mit der zugehörigen Page stehen. Falls Sie beispielsweise ein Bild nur explizit für eine ganz bestimmte Page in Ihrem Playground nutzen möchten, dann macht es Sinn, dieses Bild dem Resources-Ordner eben dieser Page hinzuzufügen und nicht der Page auf der obersten Ebene; die dort hinzugefügten Dateien stehen wiederum allen Pages Ihres Playgrounds zur Verfügung.
1.6.4 Playground-FormatierungenXcode stellt eine Reihe verschiedener Formatierungen für Playgrounds bereit, mit denen diese beispielsweise durch Überschriften und Aufzählungen optisch optimiert werden können. Der Playground kann dann dynamisch zwischen reiner Codeansicht und einer aufbereiteten formatierten Ansicht umgeschaltet werden. Letztere bietet sich dann beim Prüfen des Inhalts eines Playgrounds an, da dort die Texte, die für das Layout formatiert wurden, zwar nicht geändert werden können, dafür aber dank ihrer Formatierung eine bessere Lesbarkeit und Übersichtlichkeit bieten.
In diesem Abschnitt möchte ich Ihnen eine Auswahl der verfügbaren Formatierungen mitsamt ihrer zugehörigen Syntax vorstellen. Wichtig dabei ist, dass alle gezeigten Formatierungen innerhalb eines Kommentarblocks im Code des Playgrounds erfolgen. Es gibt zwei Möglichkeiten, derartige Kommentare in Playgrounds umzusetzen. Für einen Kommentar, der sich lediglich über eine einzige Zeile erstreckt, muss diese mit einem //: eingeleitet werden:
Sollen hingegen mehrere Zeilen auf einmal formatiert werden, so wird ein solcher Kommentarblock mittels /*: eingeleitet und mit */ wieder abgeschlossen. In den Zeilen dazwischen folgen dann die gewünschten Formatierungen. So ergibt sich der in Listing 1.1 gezeigte Aufbau.
Listing 1.1 Formatierung eines mehrzeiligen Playgrounds
/*: <ERSTE PLAYGROUND-FORMATIERUNG> <ZWEITE PLAYGROUND-FORMATIERUNG> <DRITTE PLAYGROUND-FORMATIERUNG> */
Um zwischen den beiden Ansichten ‒ der standardmäßigen reinen Codeansicht, in der auch die gezeigten Kommentare geschrieben werden, und der formatierten Ansicht ‒ zu wechseln, gibt es zwei Möglichkeiten. Einerseits können Sie über das Xcode-Menü gehen und dort Editor → Show Rendered Markup (zum Wechseln zur Formatierungsansicht) bezie-
Bild 1.43 Über das Xcode-Menü kann zwischen Formatierungs- und Codeansicht eines Playgrounds gewechselt werden.
hungsweise Editor → Show Raw Markup (zum Wechseln in die Codeansicht) auswählen (siehe Bild 1.43) oder Sie nutzen die Utilities Area; dort findet sich in der File Inspector-Ansicht (diese erreichen Sie über die Schaltfläche ganz links am oberen Rand der Utilties Area) eine Checkbox mit dem Titel Render Documentation (siehe Bild 1.44). Ist diese Checkbox aktiviert, wird die Formatierungsansicht für den Playground aktiviert, andernfalls die Codeansicht.
Bild 1.44 Die Checkbox Render Documentation der Utilities Area erlaubt das schnelle Wechseln zwischen Formatierungs- und Codeansicht eines Playgrounds.
Überschriften
Überschriften können in Playgrounds bis zu einer dritten Ebene reichen. Sie werden mithilfe des #-Zeichens erstellt; ein #-Zeichen steht für eine Überschrift der ersten Ebene, zwei #-Zeichen stehen für eine Überschrift der zweiten und drei #-Zeichen für eine Überschrift der dritten Ebene (siehe Listing 1.2).
Listing 1.2 Formatierung von Überschriften in einem Playground
/*: # Header 1 ## Header 2 ### Header 3 */
Ein so formatierter Playground sieht dann aus wie in Bild 1.45 zu sehen.
Bild 1.45 Formatierte Überschriften eines Playgrounds
Trennlinie
Eine Trennlinie in einem Kommentar wird mithilfe dreier aufeinanderfolgender Bindestriche (—) umgesetzt, so wie beispielhaft in Listing 1.3 zu sehen.
Listing 1.3 Formatierung einer Trennlinie in einem Playground
/*: Ein Text gefolgt von einer Trennlinie... --- ...und darauffolgendem weiteren Text. */
Formatiert sieht ein solcher Kommentar in einem Playground aus wie in Bild 1.46 zu sehen.
Bild 1.46 Formatierter Kommentar eines Playgrounds mit Trennlinie
Listen
Es können sowohl einfache Aufzählungen als auch nummerierte Listen mithilfe einer passenden Playground-Formatierung in einem Kommentar umgesetzt werden.
Für eine einfache Aufzählung gibt es dabei insgesamt drei Möglichkeiten: Sie können entweder einen Stern (*), ein Plus (+) oder einen Bindestrich (-), jeweils gefolgt von einem Leerzeichen, verwenden, um darüber nacheinander in aufeinanderfolgenden Zeilen die gewünschte Aufzählung umzusetzen. Listing 1.4 zeigt ein mögliches Beispiel dazu.
Listing 1.4 Eine formatierte Aufzählung in einem Playground
/*: # Einfache Aufzählung - Erstes Element - Zweites Element - Drittes Element */
Welches der drei möglichen Elemente Sie für die Aufzählung verwenden, spielt dabei keine Rolle; es wird unabhängig davon immer das gleiche Aufzählungszeichen formatiert (siehe Bild 1.47).
Bild 1.47 Eine einfache Aufzählung in einem Playground
Sie können die drei Zeichen aber auch innerhalb einer Aufzählung mischen, um zwischen den Elementen einen zusätzlichen Abstand herzustellen. Der Code in Listing 1.5 führt dann zu dem in Bild 1.48 gezeigten Ergebnis.
Listing 1.5 Mehrere entkoppelte Aufzählungen in einem Playground
/*: # Mehrere einfache Aufzählungen - Erstes Element, erste Aufzählung - Zweites Element, erste Aufzählung * Erstes Element, zweite Aufzählung + Erstes Element, dritte Aufzählung + Zweites Element, dritte Aufzählung + Drittes Element, dritte Aufzählung */
Bild 1.48 Durch parallele Verwendung der drei möglichen Aufzählungsformatierungen lassen sich bis zu drei Gruppen von Aufzählungen auf einmal erstellen.
Um eine nummerierte Liste zu erstellen, gehen Sie ähnlich vor wie bei den eben gezeigten einfachen Aufzählungen. Beginnen Sie dabei mit der Nummer, mit der die Aufzählung beginnen soll, gefolgt von einem Punkt und einem Leerzeichen, anschließend folgt der Text für das zugehörige Aufzählungselement. So fahren Sie anschließend in den darauffolgenden Zeilen für alle weiteren Elemente der nummerierten Liste fort. Listing 1.6 zeigt ein Beispiel dazu, Bild 1.49 präsentiert das zugehörige Ergebnis.
Listing 1.6 Nummerierte Liste in einem Playground
/*: # Nummerierte Liste 1. Erstes Element 2. Zweites Element 3. Drittes Element */
Bild 1.49 Eine nummerierte Liste in einem Playground
Nummerierte Listen unterstützen in Playgrounds bis zu drei Einrückungsebenen, um so eine Liste zu verschachteln. Elementen der zweiten Ebenen wird dafür ein Tab vorangestellt, Elementen der dritten Ebene zwei Tabs. Listing 1.7 zeigt ein entsprechendes Beispiel dazu, in Bild 1.50 sehen Sie das zugehörige Ergebnis.
Listing 1.7 Nummerierte Liste mit mehreren Ebenen in einem Playground
/*: # Nummerierte Liste mit Ebenen 1. Erstes Element 2. Zweites Element 1. Erstes Unterelement 2. Zweites Unterelement 1. Erstes Unterunterelement 3. Drittes Unterelement 3. Drittes Element */
Bild 1.50 Eine nummerierte Liste mit mehreren Ebenen in einem Playground
Soll eine nummerierte Liste mit einer anderen Zahl beginnen, setzen Sie diese einfach entsprechend. Alle darauffolgenden Elemente der entsprechenden Ebene werden daraufhin automatisch immer um eins hochgesetzt. Das geht sogar so weit, dass es vollkommen irrelevant ist, welche Zahl Sie ab dem zweiten Element einer Ebene im Code angeben; der Playground wird das rigoros ignorieren und ausgehend vom ersten Element der Ebene automatisch alle darauffolgenden Elemente hochsetzen. In Listing 1.8 sehen Sie ein entsprechendes Beispiel dazu, dessen durchaus überraschendes Ergebnis sehen Sie in Bild 1.51.
Listing 1.8 Nummerierte Liste mit unterschiedlichen Zahlenwerten in einem Playground
/*: # Nummerierte Liste mit automatischer Zählung 7. Erstes Element 2. Zweites Element 5. Erstes Unterelement 4. Zweites Unterelement 3. Erstes Unterunterelement 3. Drittes Unterelement 8. Drittes Element */
Bild 1.51 Obwohl den Punkten Zweites Element, Zweites Unterelement, Drittes Unterelement und Drittes Element im Code eine andere Nummer zugewiesen wurde, wird diese vom Playground ignoriert und stattdessen automatisch ausgehend von der ersten Nummer der jeweiligen Ebene hochgezählt.
Code
Zur besseren Dokumentation können Sie auch Code in einem Playground-Kommentar formatieren. Dazu müssen Sie lediglich die gewünschte Zeile, in der Sie eine solche Code-Formatierung anwenden möchten, mit einem Tab einleiten. Anschließend können Sie den gewünschten Code schreiben (siehe Listing 1.9). Beachten Sie dabei auch, dass die Zeile vor dem Code-Beispiel leer sein muss, damit die Formatierung korrekt angewendet wird. Wie das Ganze dann formatiert aussehen kann, sehen Sie in Bild 1.52.
Listing 1.9 Formatierter Code in einem Playground
/*: # Code Hier ein Code-Beispiel: print("Ein Code-Kommentar") */
Bild 1.52 Formatierung von Code in einem Playground
Anstatt ganze Zeilen als Code zu formatieren, können Sie aber auch in einem einfachen Kommentar einzelne Wörter oder Teile davon entsprechend hervorheben. Setzen Sie die entsprechenden Elemente dafür innerhalb von einfachen Anführungszeichen (`) (siehe Listing 1.10 und Bild 1.53).
Listing 1.10 Formatierter Code im Fließtext eines Playgrounds
/*: # Code Inline Hier ein Code-Beispiel mit 'print': print("Ein Code-Kommentar") */
Bild 1.53 Code lässt sich auch innerhalb von Fließtext in einem Playground-Kommentar passend formatieren.
Kursiv und fett
Texte in Playground-Kommentaren können kursiv und fett formatiert werden. Dazu wird der entsprechende Abschnitt im Falle von kursiv entweder zwischen je einem Stern (*) oder einem Unterstrich (_) eingefügt, während es bei fett jeweils zwei Sterne (**) oder zwei Unterstriche (__) sind. In Listing 1.11 und Bild 1.54 sehen Sie dazu ein passendes Beispiel.
Listing 1.11 Kursiv und fett formatierte Textstellen in einem Playground
/*: # Kursiv und Fett In diesem Satz ist etwas *kursiv* und etwas **fett**. */
Bild 1.54 Textstellen lassen sich in Playground-Kommentaren sowohl kursiv als auch fett formatieren.
Links
Um Links in einem Playground-Kommentar einzufügen, geben Sie zunächst innerhalb von eckigen Klammern den Text ein, der für den Link angezeigt werden soll, gefolgt vom Link innerhalb von runden Klammern. In Listing 1.12 sehen Sie ein Beispiel dazu, das zugehörige Ergebnis zeigt Bild 1.55.
Listing 1.12 Link in einem Playground
/*: # Link Hier geht's zu [Swift.org](https://swift.org) */
Bild 1.55 Verlinkungen können ebenfalls in einem Playground-Kommentar gesetzt und passend hervorgehoben werden.
Verlinkungen zwischen Pages
Da Playgrounds sich durchaus auch aus mehreren verschiedenen Pages zusammensetzen können (siehe dazu auch den Abschnitt 1.6.3, „Pages, Sources und Resources“), ist es an manchen Stellen womöglich sinnvoll, zwischen den verschiedenen Pages selbst zu verlinken, damit der Nutzer eines Playgrounds direkt von einer Page zu einer anderen zugehörigen Page springen kann, ohne diese selbst in der Navigator Area suchen und aufrufen zu müssen.
Für diese Form der Verlinkungen zwischen Pages gibt es prinzipiell drei Möglichkeiten. Die dynamischste besteht darin, den Namen einer Page als Link zu verwenden. Wählt der Nutzer dann diesen Link aus, springt er zu genau derjenigen Page im Playground, die diesen Namen besitzt. In Listing 1.13 sehen Sie ein Beispiel dazu, wobei davon ausgegangen wird, dass es eine Page mit dem Titel MoreInformation im Playground gibt.
Listing 1.13 Verlinkung zu einer anderen Page in einem Playground
/*: # Page-Verlinkung Weitere Informationen finden Sie [hier](MoreInformation) */
Wie Sie sehen, ist dieses Vorgehen damit identisch zu dem im vorherigen Abschnitt gezeigten Setzen von Links, nur dass statt einer Webadresse der Name einer Page als Ziel des Links angegeben wird.
Daneben gibt es noch zwei andere Möglichkeiten, zu einer anderen Page zu wechseln. Diese speziellen Verlinkungen erlauben das Springen zur vorherigen oder zur nächsten Page, ausgehend von der aktuell ausgewählten Page. Das ist ideal, wenn Sie in einem Playground eine hierarchische Navigation umsetzen und immer einen Link von einer Page zur nächsten und wieder zurück anbieten möchten. Dann nämlich brauchen Sie nicht immer explizit die jeweiligen Pages mit ihren zugehörigen Namen (wie in Listing 1.13 zu sehen war) zu verlinken, sondern Sie können stattdessen Xcode die Arbeit machen lassen. Dazu müssen Sie lediglich innerhalb des Links deklarieren, ob dieser auf die vorherige (@previous) oder die kommende (@next) Page verweisen soll (siehe Listing 1.14).
Listing 1.14 Verlinkung zur vorherigen und zur nächsten Page in einem Playground
/*: # Page-Verlinkung [Previous Page](@previous) --- [Next Page](@next) */
Neben Xcode unterstützt auch die mit iOS 10 eingeführte Swift Playgrounds-App von Apple für das iPad die in diesem Abschnitt vorgestellten Playgrounds (siehe Bild 1.56). Was dabei die Programmierung mit Swift betrifft, so sind Ihnen auch in der Swift Playgrounds-App keinerlei Grenzen gesetzt und Sie können alle Eigenschaften und Funktionen der Sprache nutzen und auch auf dem iPad anwenden.
Bild 1.56 Mit der Swift Playgrounds-App können Playgrounds auch auf einem iPad erstellt, bearbeitet und ausgeführt werden.
Allerdings bietet die App nicht einen solch großen und mächtigen Funktionsumfang wie Xcode auf dem Mac. Zwar können Sie neue Playgrounds erstellen und bearbeiten, haben aber keinen schreibenden Zugriff auf die darunterliegende Dateistruktur. Auch das Erstellen von weiteren Pages zu einem Playground ist nicht möglich, ebenso wenig wie der Wech-
Bild 1.57 Über die Swift Playgrounds-App können angepasste Playgrounds heruntergeladen werden, die spielend das Programmieren mit Swift näherbringen.
sel in eine Ansicht zur optimierten Darstellung der Kommentare und Formatierungen. Dafür stehen aber Quick Look sowie verschiedene Code-Schnipsel-Vorlagen bereit, die Sie direkt in Ihrem Playground einfügen und nutzen können. Auch das Hinzufügen zusätzlicher Dateien zu einem Playground auf dem iPad ist mittels der Swift Playgrounds-App möglich.
Vielmehr liegt der Schwerpunkt der App im Erlernen und Ausprobieren von Swift. Zu diesem Zweck können nämlich nicht einfach nur eigene Playgrounds erstellt und bearbeitet, sondern bereits vorgefertigte Playgrounds heruntergeladen werden, die sich wie interaktive Lehrbücher verhalten. Sie teilen den Bildschirm zumeist in zwei Bereiche: links Aufgaben und Instruktionen mitsamt einer Fläche zum Schreiben des Codes, rechts eine dynamische Vorschau, die das Ergebnis des geschriebenen Codes ausgibt (siehe Bild 1.57). Diese speziell für die App angepassten und optimierten Playgrounds können Sie über die Featured-Ansicht der App einsehen und auf Wunsch dort direkt herunterladen, sie tauchen dann im Bereich My Playgrounds auf und können von dort aus gestartet und genutzt werden (siehe Bild 1.58).
Bild 1.58 In der Featured-Rubrik der Swift Playgrounds-App finden sich verschiedene Playgrounds zum Download zum Experimentieren mit Swift.
Darüber hinaus verfügt die App noch über spezielle Vorlagen für neue Playgrounds. Neben einem einfachen „leeren“ Playground können Sie so auch direkt mit der Umsetzung eines Frage-Antwort-Katalogs sowie mit der Arbeit mit Graphen oder Formen beginnen (siehe Bild 1.59). Diese Vorlagen enthalten bereits vorgefertigten Code, den Sie wiederum dann in Ihrem neuen Playground verwenden und um eigene Logik erweitern können.
Bild 1.59 Mithilfe verschiedener Vorlagen können Sie bereits neue Playgrounds mit einem Grundgerüst an Funktionen erstellen.
Neben Apples IDE Xcode und der Swift Playgrounds-App für das iPad gibt es inzwischen auch noch weitere einfache Editoren, die ebenfalls Swift unterstützen und wenigstens über ein passendes Syntax-Highlighting verfügen. In den kommenden Abschnitten möchte ich Ihnen meine persönlichen Favoriten vorstellen und dabei auch einen Online-Editor zur Arbeit mit Swift präsentieren.
1.7.1 Visual Studio CodeVisual Studio gehört wohl zu den umfangreichsten und besten erhältlichen IDEs, ist aber ‒ äquivalent zu Apples Xcode für Mac ‒ nur unter Windows verfügbar. Ganz im Gegensatz zu Visual Studio Code. Es handelt sich dabei um einen kostenlosen Editor von Microsoft, der plattformübergreifend zur Verfügung steht und eine Vielzahl an unterschiedlichen Programmiersprachen unterstützt (siehe Bild 1.60).
Bild 1.60 Visual Studio Code ist ein kostenloser und plattformübergreifender Code-Editor von Microsoft.
Visual Studio Code bringt ein umfangreiches Set an Funktionen mit, verfügt über integrierte Git-Unterstützung und lässt sich nach Belieben erweitern und anpassen. Und dank seiner Plattformunabhängigkeit erlaubt er das Programmieren mit Swift sowohl unter macOS, Linux als auch Windows (siehe Bild 1.61).
Bild 1.61 Visual Studio Code steht für macOS, Linux und Windows zum Download bereit.
Weitere Informationen zu Visual Studio Code sowie den Link zum Download finden Sie auf der Projektwebsite unter https://code.visualstudio.com.
1.7.2 Syntra SmallSyntra Small ist ein weiterer einfacher Code-Editor, der exklusiv unter macOS zur Verfügung steht und über den Mac App Store kostenlos heruntergeladen werden kann (siehe Bild 1.62). Er beherrscht eine Vielzahl an verschiedenen Programmiersprachen (darunter natürlich auch Swift) und ist auf Einfachheit und Schnelligkeit ausgelegt. Einen solchen Funktionsumfang wie bei dem zuvor vorgestellten Visual Studio Code von Microsoft darf man nicht erwarten, dafür ist er wesentlich schlanker. Er eignet sich ideal zum schnellen Schreiben von Code, ohne dass irgendwelche zusätzliche Funktionen oder Eigenschaften benötigt werden.
Bild 1.62 Syntra Small ist ein schlanker und schlichter Code-Editor für macOS.
Syntra Small kann ausschließlich über den Mac App Store heruntergeladen werden. Den Link dorthin sowie weitere Informationen finden Sie auf der Projektwebsite unter http://small.syntra.io.
1.7.3 IBM Swift SandboxMit der Freigabe des Quellcodes bahnt sich Swift seinen Weg in immer mehr Bereiche. Neben neuen Plattformen wie Linux gehört dazu auch das Web. Insbesondere IBM ist hier Vorreiter und arbeitet hart daran, Swift auf die Server zu bringen. Das hat beispielsweise für App-Entwickler den großen Vorteil, dass diese dann nicht nur ihre Apps in Swift, sondern auch mögliche zusätzlich benötigte Webservices ebenfalls in Swift programmieren können; ein mögliches Erlernen und Verwenden verschiedener Programmiersprachen könnte damit wegfallen und somit langfristig der Vergangenheit angehören.
Aufgrund dieser starken Ambitionen von IBM ist es auch kein Wunder, dass sie bereits einen eigenen Online-Editor zum Schreiben und Ausführen von Swift-Code umgesetzt haben. Die IBM Swift Sandbox befindet sich zwar noch im Beta-Stadium, funktioniert dafür aber bereits erstaunlich gut. Der Editor verfügt sowohl über Syntax-Highlighting als auch Code-Completion und arbeitet extrem flott (siehe Bild 1.63
