Durchstarten mit Swift - Stefan Popp - E-Book

Durchstarten mit Swift E-Book

Stefan Popp

0,0

Beschreibung

Möchten Sie die neue Programmiersprache Swift lernen oder von Objective-C wechseln? Bauen Sie Ihre Apps am liebsten mit der neuesten Technologie und den modernsten Standards? Dann ist Durchstarten mit Swift das richtige Buch für Sie. Für Umsteiger und Newbies Durchstarten mit Swift richtet sich an Umsteiger, die bereits Erfahrung mit der Softwareentwicklung haben, aber auch an Neueinsteiger, die mit diesem Buch die Möglichkeit haben, eine Programmiersprache mit modernsten Sprachelementen zu lernen. Schritt für Schritt Swift lernen Durchstarten mit Swift führt Sie zunächst in die Swift-Grundlagen ein: Sie lernen die Entwicklungsumgebung und die Basics der Programmsteuerung kennen. Anschließend erläutern die erfahrenen Autoren die Sprachelemente, die Swift zu einer der modernsten Programmiersprachen gemacht haben, und leuchten nahezu jeden Winkel aus. Themen sind: - das Erstellen und Abrufen eigener Funktionen - einfache Datentypen und komplexe Datenstrukturen - Objektorientierung in Swift - Optionals und Container, Protokolle und Extensions - generische und funktionale Entwicklung - neu in Swift 2: Fehlerbehandlung und das guard-Statement Für die Praxis Im Praxisteil erstellen Sie Schritt für Schritt eine einfache Tracking-App mit dem Ziel, Ihre Swift-Kenntnisse zu vertiefen. Dabei wird neben einer kurzen Einführung in CoreData das Arbeiten mit dem Interface Builder erläutert. Videotutorials Die Autoren veröffentlichen begleitend und ergänzend zahlreiche kostenlose Videotutorials auf swift-blog.de. Aktuell zu Swift 2

Sie lesen das E-Book in den Legimi-Apps auf:

Android
iOS
von Legimi
zertifizierten E-Readern

Seitenzahl: 401

Das E-Book (TTS) können Sie hören im Abo „Legimi Premium” in Legimi-Apps auf:

Android
iOS
Bewertungen
0,0
0
0
0
0
0

Beliebtheit




Durchstarten mit Swift

2. AUFLAGE

Stefan PoppRalf Peters

Stefan Popp & Ralf Peters

[email protected]

Lektorat: Alexandra Follenius

Fachgutachten: Christopher Kohlert

Korrektorat: Friederike Daenecke & Sibylle Feldmann

Herstellung: Susanne Bröckelmann

Umschlaggestaltung: Karen Montgomery & Michael Oreal

Satz: III-satz, www.drei-satz.de

Druck und Bindung: Media-Print Informationstechnologie, mediaprint-druckerei.de

Bibliografische Information Der Deutschen Nationalbibliothek

Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der

Deutschen Nationalbibliografie; detaillierte bibliografische Datensind im Internet über http://dnb.d-nb.de abrufbar.

ISBN:

Buch   978-3-96009-005-2

PDF   978-3-96010-012-6

epub   978-3-96010-013-3

mobi  978-3-96010-014-0

2. Auflage 2016

Dieses Buch erscheint in Kooperation mit O’Reilly Media, Inc. unter dem Imprint »O’REILLY«. O’REILLY ist ein Markenzeichen und eine eingetragene Marke von O’Reilly Media, Inc. und wird mit Einwilligung des Eigentümers verwendet.

Copyright © 2016 dpunkt.verlag GmbH

Wieblinger Weg 17

69123 Heidelberg

Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.

Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen.

Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung für eventuell verbliebene Fehler und deren Folgen.

5 4 3 2 1 0

Inhalt

Vorwort

1     Einführung

Swift

Objective-C ohne C?

Vorteile von Swift

Swift 2.0

Die Plattform kennenlernen

2     Xcode und Co.

Installation von Xcode

Die wichtigsten Einstellungen

Eine Übersicht

Shortcuts, die das Leben erleichtern

Der Editor

Navigationsmöglichkeiten

Hilfe!

3     Die ersten Schritte

Einen Playground erstellen

Variablen und Konstanten

Benennung

Kommentare

Zahlen und Zeichenketten ausgeben

4     Kontrollstrukturen und Schleifen

if else

switch

Schleifen

for-Schleife

for-in-Schleife

while-Schleife

repeat-while-Schleife

Pattern Matching

Sprunganweisungen

Scopes

Logische Operatoren

5     Hello World

Ein iOS-Projekt erstellen

Die ersten UI-Elemente hinzufügen

Der erste Start im Simulator

Outlets und Actions hinzufügen

Ein bisschen Code muss sein

6     Datentypen und Funktionen

Datentypen

Zahlen

Funktionen

Type Aliases

7     Enumerationen und Strukturen

Aufzählungen

Strukturen

8     Klassen und Objekte

Wichtige Unterschiede und Gemeinsamkeiten

Deklaration und Instanziierung

Methoden

Statische Variablen und Methoden

Konstruktoren

Failable-Konstruktoren

Destruktoren

Properties

Lazy Properties

Vererbung

Zugangskontrolle

9     Container, Mutability und weitere Sprachelemente

Arrays

Dictionaries

Funktionen als Datentyp

Funktionen als Rückgabewert

Nested Functions

Type Casting

Subscripts

Optionals

Das guard-Statement

Fehlerbehandlung

Availability Checking

10   Protokolle und Extensions

Protokolle

Methoden

Properties

Mutating

Konstruktoren

Delegation

Vererbung von Protokollen

Protokolle mit Extensions adaptieren

Protokolle und Container

Mehrere Protokolle adaptieren

Optionale Methoden und Properties

Extensions

Standardimplementierungen für Protokolle

Operatoren überladen

11   Generische und funktionale Entwicklung

Closures

Verzögerte Berechnungen

Such- und Sortierfunktionen

Generics

12   Von der Idee zur ersten App

Überlegungen und Ideen

Projekt anlegen

Mit Core Data Daten strukturieren

UI vorbereiten

Quellcode aufräumen

Den Fetched Results Controller anpassen

Den Fetch-Request anpassen

Die Run-Entität erstellen und speichern

Timer erstellen und Zeit formatieren

13   Die App um GPS erweitern

GPS-Koordinaten integrieren

Letzte Formatierungen des RunTimer View Controllers

Die abschließende Anpassung des RunTimer- und Master View Controllers

Lust auf mehr?

Abschließendes

14   Nützliche Helfer

Rich-Text-Kommentare

Alcatraz

15   Wie geht es weiter?

Index

Vorwort

Dies ist ein Buch über Swift, eine neue Programmiersprache von Apple, die 2014 vorgestellt wurde. Binnen Stunden nach der Veröffentlichung gab es Tausende Artikel, registrierte Domains und zahlreiche Videos rund um Swift. Nicht zuletzt damit sorgte man für eine Art Goldrauscheffekt in der Entwicklergemeinde. Auch wir, die Autoren, witterten unsere Chance, auf diesen Zug aufspringen zu können, und überlegten uns Möglichkeiten, Wissen zu schaffen, ohne aber an Qualität zu sparen. Zu unserer Überraschung stellten wir nach kurzer Zeit fest, dass es kaum Material in deutscher Schrift und Sprache gab – und dann meist auch nur Kopien der von Apple veröffentlichten Entwicklerdokumentation. Für uns war von Anfang an klar, dass wir mehr als andere anbieten wollten. Wir wollten etwas Besseres und vor allem etwas Verständliches, etwas, bei dem man nicht zwischen Tausenden nutzloser Zeilen verloren geht. Wir gründeten zu diesem Zweck unser eigenes Blog Swift-Blog.de und veröffentlichten zunächst eine kleine Tutorialserie, in der wir für Anfänger Grundlagen der Softwareentwicklung mithilfe von Swift erklärten.

Wir fingen an, die Texte mit kostenlosen Videotutorials zu begleiten. Zu unserer Überraschung wurden viele Leute sehr schnell auf uns aufmerksam, und binnen Tagen hatten wir mehrere Tausend Besucher pro Tag auf unserem Blog und über 1.000 Abonnenten auf YouTube. Als unsere Smartphones nicht mehr aufhörten zu vibrieren, weil im Sekundentakt die E-Mails in die Postfächer schossen, machten wir uns auf die Suche nach der Ursache für die plötzliche Explosion. Nicht zuletzt der Newsseite iPhone-Ticker.de verdanken wir, dass viele Menschen auf uns aufmerksam geworden sind.

Ein Buch?

Manch einer mag sich fragen, warum man ausgerechnet ein Buch schreiben möchte, wenn man bereits eine Plattform hat, die funktioniert. Manch anderer fragt sich auch, warum man in der heutigen Zeit überhaupt noch Bücher schreibt, wenn man an jeder Ecke zu jedem Thema Informationen findet. Vielleicht erinnern Sie sich an das unangenehme Gefühl, einen Vortrag für die Schule oder für die Arbeit vorbereiten zu müssen, das ständige Gefühl, dass man etwas falsch beschrieben oder gar etwas vergessen hat. Und mit jeder Minute, die verstreicht und Ihren Abgabetermin näher rücken lässt, werden Sie nervöser und suchen, schreiben und korrigieren immer mehr. Denn eins ist klar: Ist der Zeiger einmal angekommen, ist das, was Sie bis dahin geschafft haben, in Stein gemeißelt, und Ihr Name steht unwiederbringlich auf dem Buchcover. Ein im Internet veröffentlichter Artikel ist dagegen schnell abgeändert, Videos sind binnen Stunden aktualisiert. Aber zu welchem Preis?

Gerade in den ersten Wochen nach der Veröffentlichung von Swift traf man immer wieder auf gleich wirkende Artikel, schlecht erklärte Tutorials sowie Massen an neuen Internetseiten, die allesamt behaupteten, hundertmal besser zu sein als die anderen. Doch unter dem Druck, etwas zu veröffentlichen, damit man der Erste ist, vergaß man eins: sich Zeit zu nehmen, Swift zu lernen und vor allem zu verstehen, damit man seine Erfahrungen verständlich weitergeben kann. Denn nicht zuletzt sind die Worte, die Sie jetzt lesen, nicht mehr von uns editierbar, und niemand wird Ihr Exemplar heimlich nach erfolgter Korrektur im Schlaf austauschen. Aus diesem Grund haben wir uns dazu entschieden, für Sie ein Buch und keine Tutorialserie zu schreiben, um von uns selbst ein hohes Maß an Qualität und Recherche abzuverlangen.

Zielgruppe

Dieses Buch richtet sich primär an Umsteiger und Wiedereinsteiger, die bereits Erfahrungen mit der Softwareentwicklung haben. Für uns war es dennoch wichtig, auch Einsteigern die Chance zu geben, Swift zu lernen. Zu diesem Zweck haben wir – soweit es uns möglich war – alles vereinfacht erklärt. Swift selbst ist zudem eine sehr junge Sprache, die aber bereits jetzt viele bewährte Paradigmen und Design Patterns von anderen Sprachen nutzt. Da wir sicher sind, dass nicht alle unsere Leser diese kennen, haben wir auch dazu entsprechende Einführungen und Erläuterungen hinzugefügt.

Beispiele und Fehler

In den meisten Büchern werden Beispiele über viele Seiten aufgebaut und ergänzt. Da man hierbei leicht den Überblick verlieren kann, war es uns wichtig, dass die überwiegende Anzahl aller Beispiele für sich allein testfähig ist. Bis auf den Programmcode, den wir in unseren Praxiskapiteln schreiben, sind alle Beispiele im normalen Playgrounds ausführbar. Sie werden Playgrounds demnächst kennenlernen und sich überwiegend darin aufhalten. Beispiele, die zusammenhängend sind, wurden von uns entsprechend mit Hinweisen versehen. Bitte verzeihen Sie uns, wenn Beispiele einmal nicht funktionieren. Häufig sind es nur kleine Fehler, die einem beim Abtippen passieren, aber gerade beim Erstellen dieses Buchs kam es auch sehr häufig vor, dass Apple grundlegende Elemente der Sprache selbst veränderte. Dies führte nicht zuletzt dazu, dass auch wir eine nicht unerhebliche Anzahl an Seiten neu schreiben mussten, was für etliche Tage Kopfschmerzen und auch Frust sorgte. Man sollte aber hierbei stets im Hinterkopf behalten, dass Swift eine sehr junge Sprache ist und noch nicht die Reife von C oder Java über mehrere Jahrzehnte erlangen konnte.

Um über aktuelle Fehler oder Nachrichten rund um dieses Buch informiert zu sein, können Sie uns für dieses Werk gern auf unserer Internetseite unter www.swiftbuch.de besuchen. Wir würden uns freuen, wenn Sie uns unter der E-Mail-Adresse [email protected] auf Fehler in diesem Buch hinweisen.

Videotutorials

Unser Blog wäre nicht so erfolgreich geworden, wenn wir keine Videotutorials produziert hätten. Gerade dank dieser Möglichkeit haben wir einen Weg gefunden, um Sie mit noch mehr Informationen zu versorgen. Ob es nur ein Tipp am Rande ist oder eine Vertiefung in ein bestimmtes Thema, ein Videotutorial kann für viele Menschen dort ein Lämpchen angehen lassen, wo auch das dritte Buch nicht geholfen hat. Aus diesem Grund war es für uns von Anfang an klar, dass wir begleitend zu diesem Buch eine Videotutorial-Reihe erstellen, in der wir die Grundlagen von Swift Stück für Stück erklären und auch vertiefen. Gerade in Hinblick auf den späteren Einstieg in die App-Entwicklung kann für die meisten Leser unsere kostenlose Einsteigerreihe sehr interessant sein. Wir laden Sie herzlichst dazu ein, unsere Videoreihe unter Swift-Blog.de zu verfolgen, und freuen uns über Kritik, Anregungen und Wünsche in unserem YouTube-Kanal oder per E-Mail an [email protected] Wie Sie sicherlich erahnen, sind die Themen mit diesem Buch verdrahtet, und wir sind überzeugt, dass Sie mit der Kombination aus diesem Buch und den Videos ein schönes und qualitativ hochwertiges Referenzwerk besitzen.

Struktur dieses Buchs

Dieses Buch besteht aus 15 Kapiteln, die Sie Schritt für Schritt in die Swift-Grundlagen einführen. In den ersten fünf Kapiteln erarbeiten Sie sich, neben grundlegenden Einführungen in die Entwicklungsumgebung, bereits einige wichtige Grundlagen zur Programmsteuerung. Ab Kapitel 6 knien wir uns hinein in die Sprache und leuchten jeden Winkel aus. An dieser Stelle sei bereits erwähnt, dass nicht alle Lektionen für die spätere App-Entwicklung in Fleisch und Blut übergehen müssen. Einzelne Lektionen auszulassen, sollten Sie – wenn möglich – aber vermeiden. Kapitel 12 und 13 sind als Praxiskapitel gedacht, um einige Techniken mit Swift zu vertiefen. Dabei bauen Sie eine App, die beispielsweise eine Fahrt mit dem Fahrrad via GPS aufzeichnet und protokolliert. Das Kapitel 15 fasst Links und Ressourcen zusammen, um Sie auf den richtigen Weg zu bringen, wenn Sie dieses Buch durchgearbeitet haben.

Kapitel 1, Einführung

Eine Übersicht über Historie und Entstehung von Swift sowie ihrer Vorteile.

Kapitel 2, Xcode und Co.

Eine Anleitung zur Installation der benötigten Entwicklungsumgebung sowie eine Erklärung für deren Benutzung und Konfiguration.

Kapitel 3, Die ersten Schritte

Gibt eine kurze Übersicht über Playgrounds und stellt einige Grundlagen für die ersten kleinen Gehversuche mit Swift vor.

Kapitel 4, Kontrollstrukturen und Schleifen

Dient dem Erlernen verschiedener Techniken, um den Programmablauf zu steuern und zu beeinflussen.

Kapitel 5, Hello World

Ein Praxiskapitel, in dem man einen kurzen Überblick über den Interface Builder sowie das Steuern einer App mit UI-Elementen erhält.

Kapitel 6, Datentypen und Funktionen

Stellt das Rechnen mit Zahlen sowie das Erstellen und Aufrufen eigener Funktionen vor.

Kapitel 7, Enumerationen und Strukturen

Dient dem Erlernen des Erstellens von einfachen Datentypen wie Zahlen oder Zeichenketten und komplexen Datenstrukturen.

Kapitel 8, Klassen und Objekte

Gerade die Objektorientierung ist für viele Entwickler und Einsteiger ein schwieriges Thema, das in diesem Kapitel von Grund auf mit Swift erklärt wird.

Kapitel 9, Container, Mutability und weitere Sprachelemente

Bietet eine Übersicht und eine Vertiefung zu verschiedenen Sprachelementen, wie Funktionen und der Fehlerbehandlung, sowie wichtige Grundlagen über Optionals und Type Casting.

Kapitel 10, Protokolle und Extensions

Stellt unter anderem verschiedene Techniken zum Erweitern und Definieren von Klassen vor und bietet eine Einführung in das Delegation Pattern und die protokollorientierte Programmierung.

Kapitel 11, Generische und funktionale Entwicklung

Dient dem Überblick über eins der wohl schwierigsten Themen in Swift. Neben der generischen Programmierung wird hier der Fokus auch auf die funktionale Entwicklung gelegt und erklärt.

Kapitel 12, Von der Idee zur ersten App

Erklärt und beschreibt Schritt für Schritt das Erstellen einer eigenen Tracking-App. Dabei wird neben einer Einführung in CoreData das Arbeiten mit dem Interface Builder vertieft.

Kapitel 13, Die App um GPS erweitern

Erweitert die Runner-App mit der Aufzeichnung von GPS-Daten sowie deren Darstellung mithilfe von MapKit auf einer Karte.

Kapitel 14, Nützliche Helfer

Dieses Kapitel behandelt das Kommentieren der Extraklasse mithilfe von Markups sowie das Erweitern von Xcode mit Plug-ins.

Kapitel 15, Wie geht es weiter?

Eine Sammlung von nützlichen Links, Dokumenten und Orten, um mit Swift großartige Apps bauen zu können.

Typografische Konventionen

In diesem Buch werden die folgenden typografischen Konventionen verwendet:

Kursivschrift

für Datei- und Verzeichnisnamen, Menüs, E-Mail-Adressen und URLs, aber auch bei der Definition neuer Fachbegriffe und für Hervorhebungen

Nichtproportionalschrift

für die Codebeispiele und Code im Text

Dieses Symbol kennzeichnet einen Hinweis, der eine nützliche Bemerkung zum nebenstehenden Text enthält.

Dieses Symbol kennzeichnet eine Warnung, die sich auf den nebenstehenden Text bezieht.

Die zweite Auflage

Zwischen der ersten und der zweiten Auflage dieses Buchs hat sich einiges getan, und Apple hat keine Zeit und Mühe gescheut, Swift besser und zukunftsträchtiger zu gestalten. Dabei hat man nicht nur versucht, weitere neue Sprachelemente zu integrieren, vielfach gab es auch Anpassungen der Syntax selbst. Das Compiler-Team rund um Lattner ist sehr darauf bedacht, auch Einflüsse von außen zu betrachten und zu bewerten. Somit kam es bereits bei der Veröffentlichung von Swift 1.2 zu zahlreichen Veränderungen, die viele Entwickler zum Ändern ihrer Programme zwangen. Der im Xcode mitgelieferte Migrator konnte dies in den meisten Fällen aber problemlos und automatisch für die Entwickler erledigen.

In der ersten Auflage dieses Buchs basierten die Beispiele und Erklärungen auf dem Stand von Swift 1.1, das mittlerweile als veraltet gilt. Das erste große Update von Swift kam am 8. April 2015 mit Version 1.2 und enthielt neben vielen Bugfixes, die für deutlich mehr Stabilität sorgten, auch erste große Veränderungen von Abläufen und der Syntax. Mit Version 2.0 kamen ebenfalls diverse Anpassungen und Erneuerungen, wie z.B. Protocol Extensions oder auch das Fehlermanagement, hinzu.

Das Buch wurde vollständig auf Version 2.0 angepasst, und alle neuen und veränderten Paradigmen und Schlüsselwörter wurden von uns nach bestem Gewissen gepflegt und ergänzt. Da Swift immer noch eine sehr junge Sprache ist, kann es Änderungen geben, die Teile dieses Buchs ungültig machen. Auf unserer Buchwebseite http://www.swiftbuch.de können Sie sich aber jederzeit über mögliche Veränderungen und Fehler informieren.

Danksagungen

Das Schreiben eines Buchs beschränkt sich bei Weitem nicht nur auf eine einzelne Person, und wir haben so vielen Menschen so vieles zu verdanken. Vor allem unseren Freundinnen Ricarda und Sahra sei gedankt, die uns für die zweite Auflage erneut bedingungslos den Rücken freigehalten haben. Unseren Eltern, die bis heute nicht verstehen, was dieses »Programmieren« eigentlich ist. Herrn Volker Bombien für seinen Einsatz, dieses Buch beim O’Reilly Verlag zu ermöglichen, sowie für dessen Nerven aus Stahl bei der ersten Auflage, als wir einen Tag vor der Manuskriptabgabe noch 1.000 Fragen an ihn hatten. Wir danken auch Frau Alexandra Follenius sehr, die das Steuer für die zweite Auflage in die Hand genommen und uns professionell und kompetent bis zum Schluss begleitet hat. Außerdem ein großer Dank an Herrn Robert Scherer, der Stefan Popp über mehrere Jahre hinweg motiviert hat, doch endlich mal ein Buch zu schreiben. Natürlich danken wir auch unseren YouTube-Zuschauern sowie unseren Bloglesern für das Verständnis, eure Kritiken, Kommentare und zahllosen E-Mails!

Ein ganz besonderer Dank gilt Christopher Kohlert, mit dessen Hilfe dieses Buch erneut rechtzeitig fertig geworden ist. Ebenfalls gilt unser Dank den Käufern der ersten Auflage und auch allen fleißigen Helfern, die uns Fehler im Buch mitgeteilt haben.

Selbstverständlich danken wir Ihnen aber am meisten für den Kauf dieses Buchs. Ohne Ihre Unterstützung könnten Buchprojekte wie dieses nicht existieren.

Zu guter Letzt gilt mein liebevoller Dank meinem Vater Andreas Popp, der 2013 gestorben ist. Ohne dich hätte ich niemals den Willen und die Kraft gehabt, weit über das hinauszugehen, was andere in mir gesehen haben.

KAPITEL 1

Einführung

Als bei der WWDC 2014 (Apples Worldwide Developer Conference) die Worte »We have a new programming language« fielen, wurde es in dem 5.000-PersonenSaal zunächst einmal sehr laut. Auch in den Tagen darauf wurde im Internet sehr viel spekuliert, wie sich diese Ankündigung auf die iOS- und OS X-Entwicklergemeinde auswirken könnte. Aufgrund dieser Neuerungen haben wir damit begonnen, uns auf diese Sprache zu konzentrieren und mithilfe unserer Objective-CErfahrungen Apps mit Swift zu entwickeln. Auch wenn Objective-C weiterhin Verwendung findet und von Apple weiterentwickelt wird, so wird Swift doch eine bedeutende Rolle spielen.

Swift

Schon im Juli 2010 machte sich der in Open-Source-Kreisen bekannte promovierte Computerwissenschaftler Chris Lattner seine ersten Gedanken zu einer neuen Programmiersprache, die wir nun unter dem Namen Swift kennen. Zuvor schrieb er im Jahr 2000 unter Leitung von Vikram Adve an der Universität von Illinois an dem Forschungsprojekt LLVM (Low Level Virtual Machine) – einem weit bekannten modularen und quelloffenen Compiler-Unterbau – mit, der inzwischen vielen Firmen als Frontend dient, um speziellen maschinen- und sprachunabhängigen Zwischencode für unterschiedlichste Programmiersprachen zu generieren, der dann von LLVM für Optimierungen und die letztendliche Codeerzeugung einer Applikation verwendet wird. 2005 wurde Apple auf das Projekt aufmerksam, stellte ein Entwicklungsteam zu Verfügung und setzte Lattner als Leiter ein.

In der Praxis wurde bisher eher der GCC-Compiler (GCC – GNU Compiler Collection) eingesetzt, ein Projekt, das in der Linux-Welt groß wurde und in den 80erJahren von Richard Stallman, einer schillernden Figur der Open-Source-Bewegung, begonnen wurde.

2007 fingen Chris Lattner und sein Team an, für LLVM ein Frontend für C/C++ und Objective-C zu bauen. Im September 2009 galt es als stabil, und ab Juni 2010 wurde der GCC auf der Apple-Plattform mit dem Entwicklerpaket Xcode durch das neue Frontend namens Clang verdrängt, das seither als Compiler für all die Apps dient, mit denen wir iPhones, Tablets und Macs bestücken.

LLVM ist inzwischen sehr mächtig und funktioniert wirklich gut. Kein Wunder also, dass es auch als Grundlage für Lattners neuestes Projekt genutzt wird: für die Programmiersprache Swift.

Im Sommer 2012 begann Lattner in seiner Freizeit – nachts und an Wochenenden – erstmals ernsthaft an der Sprache zu arbeiten, und als er am Ende des Jahres seine Konzepte dem Management von Apple vorlegte, waren die Manager beeindruckt genug, um ihm ein Team erfahrener Entwickler zur Seite zu stellen. Knapp 18 Monate später rückte das Projekt weiter in den Fokus von Apple, und ab dem Zeitpunkt arbeitete ein großes Team daran, die Sprache rasch für eine Veröffentlichung auf der Keynote am 2. Juni 2014 fit zu machen.

Als Swift auf der Keynote vorgestellt wurde, war dies, mit Ausnahme eines kleinen Kreises von Apple-Insidern, für alle eine große Überraschung. Sogar Vikram Adve, mit dem Lattner ja ursprünglich eng zusammengearbeitet hatte, bekam die Neuigkeit erst auf der Keynote mit.

Doch wozu eine neue Programmiersprache? Schon 2009 hat sich Google mit einer neuen Sprache namens »Go« versucht und muss seitdem hart um neue Anhänger kämpfen. Facebook kreierte mit der Sprache »Hack« eine Abwandlung von PHP, die seither primär die Server des Facebook-Imperiums antreibt. Neue Sprachen kommen und gehen, was macht Swift so besonders?

Interessanterweise ist ein nicht unwesentlicher Punkt bei der Beantwortung dieser Frage die bisherige Sprache der Apple-Plattform: Objective-C.

Objective-C stammt, ähnlich wie die Sprache C++, aus den 80er-Jahren und ist ein objektorientierter Aufsatz auf die verbreitete Sprache C, die zwar als Hochsprache durchgeht, aber nur sehr knapp die komplizierten Hürden der darunterliegenden Maschinensprache abstrahiert.

Die Syntax von Objective-C ist jedoch nicht gerade einfach: Man merkt an vielen Stellen, dass sie nur ein Zuckerguss über C ist, der versucht, etwaige Kompatibilitätsprobleme mit C oder C++ zu vermeiden. Mit dem GCC-Compiler konnte man deshalb sogar in einer Quellcodedatei C, C++ und Objective-C mischen. Für viele Anfänger war das eine unüberwindbare Hürde, und auch Profis werden sich über eine modernere und einfacher zu bedienende Sprache wie Swift freuen.

Dank Lattner und dem Umstand, dass Apple sowohl seine Entwicklerwerkzeuge wie Xcode als auch die Sprache Swift vollständig unter Kontrolle hat, arbeiten alle Tools perfekt zusammen, und Swift ist in die iOS- und Mac OS X-Landschaft vollständig integriert.

Die Hunderttausende Entwickler, die Apps für Macs, iPhones und all die anderen iGeräte entwickeln, haben somit einen echten Grund, sich die Programmiersprache Swift genauer anzusehen. Und da sie die Wahl zwischen Objective-C und Swift haben, werden viele zu Swift wechseln.

Schon einen Monat nach der Vorstellung der Sprache Swift war sie auf dem TIOBE-Index (http://www.tiobe.com) – einer Liste der beliebtesten Programmiersprachen – auf Platz 16; auf dem PYPL-Index rangierte sie sogar auf Platz 11, und dank der Marktmacht von Apple wird Swift schnell einen wesentlichen Einfluss auf die Plattform ausüben.

Schon jetzt gibt es auf GitHub weit über 15.000 Projekte, die in Swift geschrieben sind, und da Apple die Sprache Ende 2015 als Open Source zu Verfügung stellt, hat sie gute Chancen, auch auf anderen Plattformen Fuß zu fassen und an Bedeutung zu gewinnen.

Objective-C ohne C?

Swift ist eine moderne, objektorientierte Sprache, die laut Apple versucht, das Beste aus C und Objective-C zu übernehmen, jedoch auf deren Einschränkungen zu verzichten. In Wahrheit ist Swift jedoch eine völlig neue Sprache, die eher an JavaScript oder Skriptsprachen wie Rust oder Python erinnert als an veraltete Sprachkonzepte aus den 80er-Jahren.

Swift hat die üblichen Spracheigenschaften, die man bei einer neuen Sprache erwartet: Klassen, einstufige Vererbung, Closures, generische Typen, Namespaces und ein paar Sachen, die man primär von Objective-C kennt: die Unterstützung von Protokollen (ein ähnliches Konzept wie Java-Interfaces, die auch historisch von Objective-C beeinflusst waren) und automatisches Speichermanagement mittels Reference Counting (ARC). Relativ neu sind multiple Rückgabewerte, also die Rückgabe von Tuples. Enumeratoren sind deutlich komplexer als in C/C++ gestaltet, Pointer gibt es im Grunde gar nicht mehr (nur eine Abstraktion für den Fall, dass man unbedingt C/C++-APIs ansprechen muss), einige Details der Sprache wirken manchmal zu sehr nach »Syntactic Sugar«, und es ist nicht mehr an jeder Stelle offensichtlich, was die Sprache unter der Haube erzeugt, so wie das früher in C/C++ und auch in Objective-C noch eher der Fall war.

Die Runtime von Swift ist ziemlich eng mit der Apple-Plattform und damit auch mit Objective-C verbunden. So sind z.B. die Datenformate eines Arrays von Swift und die String-Implementierung intern binär kompatibel mit den Objective-C-Foundation-Framework-Objekten NSArray und NSString, um einen Austausch zwischen Swift und den Objective-C-APIs so schnell wie möglich zu gestalten. (Im einfachsten Fall findet nur ein retain und release statt.)

Vorteile von Swift

Swift kann selbstverständlich mit allen Frameworks und APIs der Apple-Plattform interagieren und ist dabei sogar schneller als Objective-C.

Das liegt einerseits am Sprachdesign – etwa an dem Umstand, dass die Funktionen von Structs im Normalfall immutable sind (im C++-Jargon würde man wohl const dazu sagen, dort sind immutable Funktionen jedoch eher die Ausnahme), was dem Compiler stärkere Optimierungsmöglichkeiten gibt. Andererseits liegt es daran, dass Objective-C schlicht langsam ist. Da Objective-C Dynamic Binding unterstützt, muss jeder Aufruf einer Klassenfunktion durch eine aufwendige Indirektion gehen, da die Funktionen in Objective-C zur Laufzeit ausgetauscht werden könnten. Außerdem verhindert diese Architektur an einigen Stellen eine Optimierung durch den Compiler. Diese Ineffizienz hat Swift beseitigt. Swift ist allein dadurch teilweise doppelt so schnell wie Objective-C.

Swift unterstützt auch das Type Inferring, findet also den benötigten Typ neuer Variablen und Konstanten selbst anhand des rvalue heraus – also anhand des Typs, den die Information hat, die der neuen Variablen zugewiesen werden soll. Das spart Programmierarbeit. (In C++11 hat man dafür das auto-Keyword, aber das muss man trotzdem erst hinschreiben.) Solche Eigenschaften machen die Sprache Swift für Einsteiger und auch für Profis übersichtlicher. Lattner selbst schreibt, es wäre ihm ein Anliegen, das Programmieren zugänglicher zu machen, weil er hofft, damit mehr Leute zum Programmieren zu bewegen.

Abbildung 1-1: Ein Playground in Swift

Ein weiterer wesentlicher Vorteil von Swift respektive seiner Programmierumgebung in Xcode sind Playgrounds. Chris Lattner hat sich, wie er selbst auf seiner Homepage schreibt, bei dieser Eigenschaft vom Produktdesigner Bret Victor (http://worrydream.com) und der Implementierung seiner Editoridee von Chris Granger (http://chris-granger.com) mit dem Namen »Light Table« inspirieren lassen. Der Editor für Swift-Code ist in zwei vertikale Abschnitte unterteilt. Auf der linken Seite kann man Code eingeben, und auf der rechten Seite sieht man schon während des Editierens die Ergebnisse des Codes. Durch eine REPL (Read-Eval-Print-Loop) wird der neu geschriebene Code direkt beim Editieren immer wieder in das Programm gepatcht und neu ausgeführt. So sieht man die jeweiligen Ergebnisse sofort und kann sogar in einigen Fällen damit interagieren. Durch diesen Trick bekommt man nicht nur extrem schnell Feedback dazu, was der gerade geschriebene Code tatsächlich tut, man spart sich auch vermeintlich den Kompilationsvorgang, da das Programm immer aktuell ist und auch sofort ausgeführt werden kann.

Swift 2.0

Auf der WWDC 2015 hat Apple Swift 2.0 angekündigt. Die neue Version besticht durch bessere Performance, bessere Fehlerbehandlung, eine verfeinerte Sprachsyntax, eine bessere Integration in die SDKs von Apple und einen stärkeren Fokus auf protokollorientierte Programmierung. Des Weiteren wird Apple Ende 2015 Swift als Open Source herauszugeben, damit es dann unter anderem auch unter Linux für die Entwicklung genutzt werden kann. Die Portierung auf weitere Plattformen wie z.B. Windows wird somit ebenfalls ermöglicht werden. Wer weiß, vielleicht bilden sich zukünftig Cross-Plattform-Frameworks, in denen Apps dann sowohl auf OS X als auch Linux und Windows in Swift geschrieben werden können. Ähnlich wie für node.js sollte es aber nach absehbarer Zeit auch möglich sein, Webanwendungen in Swift zu schreiben.

Und nicht zu vergessen: Swift ist schnell, Swift ist mächtig, und hinter Swift steht mit Apple die momentan teuerste Firma Amerikas – oder, um es mit Andrei Alexandrescus (Facebooks Programmierguru) Worten zu sagen: »Alles, was Swift nun noch tun muss, um zu gewinnen, ist: nicht völlig zu versagen.«

Die Plattform kennenlernen

Mit Swift ist es Ihnen möglich, die komplette Palette der Apple-Plattform abzudecken. Diese unterteilt sich derzeit in iOS (also iPhone, iPad, iPod touch) und OS X (also alle gängigen MacBooks, MacBook Pros, iMacs und Mac Pros).

In diesem Buch werden wir für unsere Praxisteile die iOS-Plattform nutzen, da der Einstieg in sie deutlich einfacher ausfällt als der Einstieg in die OS X-Entwicklung.

iOS

iOS (oder auch iPhone OS, wie es bei seiner Vorstellung am 9. Januar 2007 noch genannt wurde) ist das Betriebssystem für die oben genannten iDevices. Das am 6.

März 2007 veröffentlichte iPhone SDK bietet Entwicklern weltweit die Möglichkeit, in dem am 11. Juli 2008 eröffneten App Store ihre Apps zu veröffentlichen.

Inzwischen gibt es mehr als 1,5 Millionen Apps im Apple App Store (Stand: Juni 2015).

iOS unterstützt 32- und 64-Bit-ARM-Prozessoren und basiert auf einer speziell für das iPhone angepassten OS X-Version, die auf Unix basiert. Die aktuellen Prozessorarchitekturen sind ARMv7, ARMv7s und ARMv8. Die bisherige Programmiersprache war Objective-C 2.0, eine Mischung mit C oder C++ ist aber möglich. Darüber hinaus bieten einige Hersteller die Möglichkeit, mithilfe von speziellen Programmen Apps in anderen Sprachen zu programmieren. Im Juni 2014 wurde Swift zu den nativen Entwicklungssprachen dieser Plattform hinzugefügt. Und auch mit der Veröffentlichung von iOS 8 und iOS 9 gab es wieder viele Erweiterungen der von Entwicklern verfügbaren APIs.

Die Installation von iOS 8/iOS 9 ist nur auf Geräten ab iPhone 4S und neueren Modellen möglich.

Swift beherrscht und nutzt, wie auch Objective-C, das Cocoa und Cocoa Touch Framework, das überwiegend in Objective-C programmiert wurde. Dadurch wird der Umstieg von Objective-C sehr erleichtert: Sie als Programmierer nutzen stets die gleiche API, egal in welcher Sprache Sie entwickeln.

Mac OS X

OS X ist das Betriebssystem für Apples Desktopcomputer, wie iMac, MacBook Pro oder auch Mac Pro. Es basiert auf einem Unix-Kernel, dessen Name Darwin ist. Gerade durch seine Nähe zu Unix und Linux ist Mac OS X für Entwickler ein sehr beliebtes Betriebssystem.

OS X selbst unterstützt 32- und 64-Bit-Anwendungen. Wie bei iOS war die bisherige Programmiersprache Objective-C. Sie können Swift aber ebenso einfach für diese Plattform nutzen wie für iOS. Es gibt jedoch einige und zum Teil große Unterschiede bei der allgemeinen Entwicklung von Applikationen für OS X und iOS. iOS wird dabei allgemein als die Plattform für den einfacheren Einstieg angesehen.

Für die allgemeine Applikationsentwicklung kommt ebenfalls das Foundation Framework sowie für die Entwicklung von Desktopapplikationen das AppKit-Framework zum Einsatz. OS X und iOS teilen sich eine ganze Reihe von Frameworks, wobei es gerade bei der Oberflächenentwicklung noch große Unterschiede zwischen zwischen AppKit und UIKit gibt. Wir persönlich hoffen auf ein gemeinsames Framework, damit Applikationen zwischen den beiden Plattformen einfacher portierbar werden.

watchOS

watchOS wurde als Betriebssystem für Apples iWatch entwickelt. Es basiert auf einer modifizierten iOS-Version. Dadurch teilen sich beide Plattformen viele Eigenschaften, ähnliche Entwicklungsparadigmen erleichtern den Austausch zwischen iOS und watchOS bei der Entwicklung.

Zu Beginn konnte man nur eine Handvoll APIs nutzen, um auf der Watch Daten anzuzeigen. Dank watchOS 2 wird es aber möglich, Applikationen nativ auf der Uhr bereitzustellen. Dadurch ergeben sich völlig neue Möglichkeiten neben der einfachen Anzeige von Daten. Da watchOS noch sehr jung ist, kann man aber erwarten, dass sich hier noch radikale Änderungen an den APIs ergeben könnten.

tvOS

Am 9. September 2015 wurde für Entwickler der Zugang zum tvOS SDK ermöglicht, das für die Entwicklung von Apps für AppleTV verwendet wird. tvOS selbst basiert laut Aussage von Apple zu 95% auf iOS 9. Entwickler erhalten dadurch nicht nur ein sehr ausgereiftes Betriebssystem für AppleTV, sie können dabei fast problemlos Anwendungen wie Spiele auf das AppleTV portieren. Zu dem Zeitpunkt, als dieses Buch verfasst wurde, gab es keine Möglichkeit, Webinhalte anzuzeigen, wodurch Apple die AppleTV-Entwickler geradezu zwingt, Applikationen nativ zu entwickeln. Da tvOS selbst ein sehr neuer und frischer Markt für AppEntwickler ist, wird es sicherlich eine spannende Zeit werden, die Plattform reifen zu sehen.

KAPITEL 2

Xcode und Co.

Bevor wir mit der Einführung in Swift und der Entwicklung beginnen können, müssen wir zuerst unsere IDE (Integrated Development Environment) aufsetzen. Apple stellt hierfür Xcode kostenlos zur Verfügung, das uns viele nützliche Funktionen anbietet, um effizient und schnell Apps entwickeln zu können. Eine IDE hat unter anderem den Vorteil, dass sie eine sogenannte Autocompletion besitzt. Diese vervollständigt z.B. automatisch Methoden und Variablennamen. Dieses Thema wird später in der einen oder anderen folgenden Lektion behandelt. Die IDE verweist mit Meldungen auf Fehler und gibt Hinweise zu deren Behebung. Das Ganze geht heutzutage sogar so weit, dass die IDE uns auch Korrekturvorschläge – unter Xcode sogenannte Fix-its – für häufige Entwicklerfehler anbietet. Lediglich eine Apple-ID ist für den Download notwendig, doch auch dafür fallen keine Kosten an. Wie und wo man die Entwicklungsumgebung herunterlädt, wie man sie einrichtet und wie man sich mit Einstellungen und Tastenkürzeln das Entwicklerleben erleichtert, werden wir Ihnen in diesem Kapitel Stück für Stück näherbringen.

Installation von Xcode

Ehe wir Xcode installieren können, müssen wir es erst einmal herunterladen. Die aktuellste Version erhalten Sie im Apple Mac App Store.

Dafür ist eine gültige Apple-ID notwendig, die Sie sich unter https://appleid.apple.com/de kostenfrei erstellen können. Nach erfolgreicher Registrierung können Sie Xcode einfach über die App Store-App herunterladen. Dafür öffnen Sie diese einfach und geben in das Suchfeld »Xcode« ein. Nachdem Sie bei den Suchergebnissen auf den Download-Button geklickt haben, werden Sie aufgefordert, Ihre Apple-ID einzugeben. Den Rest – also Download und Installation – regeln die App und Ihr OS X allein.

Sie können auch die Spotlight-Suche von OS X nutzen, um schnell die Xcode-App im App Store zu finden. Geben Sie hierfür nur »Xcode« in das Spotlight-Textfeld ein und wählen Sie das entsprechende Suchergebnis aus.

Abbildung 2-1: Xcode im App Store

Den Download- und Installationsfortschritt können Sie über das Launchpad verfolgen. Dieses erreichen Sie entweder über das Dock-Icon (sofern vorhanden) oder über die Taste .

Beim ersten Start von Xcode werden noch einige systemspezifische Dateien installiert. Dadurch wird der Setup-Vorgang finalisiert. Im Anschluss daran sollte das Willkommensfenster von Xcode 7 erscheinen.

Sollte das Willkommensfenster nicht auftauchen, aber in der Menubar bereits Xcode stehen, können Sie über die Menüleiste WINDOW → WELCOME TO XCODE oder das Tastenkürzel das Fenster manuell öffnen.

Die wichtigsten Einstellungen

Die Standardeinstellungen von Xcode bereiten Ihnen schon eine fast perfekte Umgebung vor. Unserer Erfahrung nach sollte man aber noch einige Einstellungen verfeinern. Hierfür navigieren wir zunächst einmal zu den Einstellungen.

Selbstverständlich muss Xcode 7 geöffnet und im Vordergrund ausgewählt sein, sodass wir in der Menüleiste über den Punkt XCODE → PREFERENCES das entsprechende Fenster öffnen können (siehe Abbildung 2-2).

Abbildung 2-2: Xcode-Einstellungen

Die für uns vorerst wichtigsten Einstellungsoptionen befinden sich unter den Menüpunkten Fonts & Colors sowie Text Editing. Hier können Sie unter anderem das Farbthema im Editor einstellen, egal ob es Ihnen um die Kolorierung der Syntax oder um einen hellen oder dunklen Hintergrund geht. Es gibt eine relativ große Auswahl an vordefinierten Farbthemen, z.B. eine Präsentationsansicht, die sich besonders bei der Beamer-Nutzung bewähren sollte. Zusätzlich ist es auch möglich, selbst Farbthemen zu erstellen oder fertige Themen von externen Internetseiten herunterzuladen und zu importieren.

Unter dem Menüpunkt Text Editing empfiehlt es sich, die Checkbox neben dem Punkt Line numbers auszuwählen. Ebenso sollten Sie einen Page guide at column-Wert definieren (siehe Abbildung 2-3).

Die Liniennummerierung, die Sie üblicherweise aus anderen Entwicklungsumgebungen kennen, ist aus unserer Sicht ein absolutes Muss, denn sie hilft sowohl bei der Navigation als auch bei der Fehlersuche nach Konsolenausgaben.

Ebenso empfiehlt es sich, den Page guide at column-Wert zu definieren und sich auch an diese Regel zu halten. Es ist immer sinnvoll, sich an der maximalen Zeichenbegrenzung pro Linie zu orientieren, sowohl der Übersichtlichkeit als auch der Lesbarkeit zuliebe.

Wir empfehlen einen maximalen Wert von 100 bis 120 Zeichen, da alles, was darüber hinausgeht, unübersichtlich wird und wahrscheinlich auch die meisten Bildschirmgrößen sprengt.

Mit dem Update von Xcode 5 hat Apple den Entwicklern einen lästigen und komplizierten Arbeitsschritt abgenommen: die Provisioning-Profile und die Teamorganisation. Um diese auch voll nutzen zu können, ist es ratsam, unter dem Menüpunkt ACCOUNTS seine Apple-ID einzutragen, sodass bei der Entwicklung Xcode automatische Synchronisierungen mit dem Developer-Account vornehmen kann.

Abbildung 2-3: Xcode-Einstellungen zum Text-Editing

Einen Entwickler-Account können Sie für 99 Euro pro Jahr unter http://developer.apple.com/ erhalten.

Unter DOWNLOADS findet sich noch die Möglichkeit, die Dokumentation (iOS 9 doc set, Xcode 7 doc set usw.) herunterzuladen, sodass deren Inhalte auch offline für Sie verfügbar sind. Hier können Sie außerdem auch ältere Simulator-iOS-Versionen laden, falls diese für die Entwicklung notwendig sind.

Eine Übersicht

Wir haben Xcode geladen, installiert und alle notwendigen Einstellungen vorgenommen. Jetzt wollen wir einen näheren Blick auf die Umgebung werfen.

Hier sehen Sie die Entwicklungsumgebung Xcode in ihrer vollen Pracht. Die einzelnen Fensterkomponenten haben wir der Übersichtlichkeit halber aufgeteilt und mit den Buchstaben A bis F benannt. Sie werden erkennen, dass der Editor (B) und das Utility-Fenster (E) je nach ausgewählter Projektdatei verschiedene Inhalte anbieten. Darauf gehen wir in den einzelnen Abschnitten detailliert ein.

Abbildung 2-4: Xcode-Übersicht

A – Das Navigationsfenster

Das Navigationsfenster ist in acht Bereiche unterteilt, in denen Ihnen verschiedene Navigationsmöglichkeiten zur Verfügung stehen (siehe Abbildung 2-5).

Abbildung 2-5: Das Navigationsfenster

1. Projekt-Navigator

Der Projekt-Navigator, der auch aus anderen Entwicklungsumgebungen (z.B. Eclipse) bekannt ist, dient zur Navigation und zum Organisieren der Dateien innerhalb eines Projekts. Dabei erkennen wir, dass Xcode beim Erstellen eines neuen Projekts selbstständig eine geordnete Struktur anlegt.

Hier sehen Sie an oberster Stelle das Projekt Runner mit der Detailangabe 2 targets, iOS SDK 9.0. Die Information, dass in diesem Projekt das iOS 9-SDK verwendet wird, ist selbsterklärend und informiert den Entwickler über die verwendete Version des Software Developer Kit und des Deployment-Target. Als Target bezeichnet man das Produkt, das aus den Projektdateien erstellt wird. Wir haben hier bereits zwei Targets, da das erstellte Xcode-Projekt für Unit-Tests als eigenes Target erkannt wird. Die kompilierten Applikationen sehen Sie übrigens im letzten Ordner, Products, dessen Inhalt rot markiert ist, da diese Dateien bisher nicht im Projektordner vorhanden sind.

Sie können mehrere Targets verwenden, wenn Sie ein und denselben Programmcode für mehrere Produkte verwenden möchten. Dies findet z.B. häufig bei bekannten Spielen mit derselben Logik, aber unterschiedlicher Oberfläche Anwendung.

Dateien mit dem Suffix .swift sind in unserem Projekt Quellcodedateien. Sie finden in unserem Projekt unter anderem AppDelegate.swift und MasterViewController.swift.

Zudem sehen Sie die Interface-Builder-Datei Main.storyboard und eine Images.xcassets. In der .storyboard-Datei können Sie einfach per Drag-and-drop User-Interface-Elemente arrangieren. Die Images.xcassets steht uns seit Xcode 5 und iOS 7 zur Verfügung und dient der besseren Verwaltung von Bilddateien. So werden hier nicht nur App-Icons und Launch-Images hinterlegt, auch alle zusätzlich in der App verwendeten Bilder können hier abgelegt, sortiert und benannt werden. Das Problem der Unübersichtlichkeit aufgrund von häufiger Doppelbenennung durch Standard- und Retina-Grafiken wurde hier ebenfalls elegant gelöst.

Des Weiteren sehen Sie hier die sogenannten Supporting Files, in denen z.B. die Info.plist liegt. Diese Property List beinhaltet unter anderem Versionsnummern, Lokalisierungskürzel und Produktkategorien.

Viele Third-Party-Frameworks (z.B. aus dem Bereich der sozialen Netzwerke) setzen voraus, dass hier die jeweiligen Produkt- oder API-Schlüssel abgelegt werden.

Die Funktion des Projekt-Navigators sollte selbsterklärend sein. Sie können hier Ihre Dateien auswählen, verschieben, organisieren, in Ordnerstrukturen verpacken oder einfach löschen. Zudem gibt es am unteren Ende des Fensters eine Filterfunktion, mit der Sie schnell einzelne Dateien nach Namen oder Typ suchen können.

2. Symbol-Navigator

Im Symbol-Navigator finden Sie, ähnlich wie im Projekt-Navigator, alle Implementierungsdateien, nur in anderer Darstellung.

Abbildung 2-6: Der Symbol-Navigator

Die Namen AppDelegate und MasterViewController, die uns auch im vorigen Punkt begegnet sind, stellen Klassen dar, die wiederum einzelne Methoden beinhalten. Hier können Sie sehr schnell auch bei großen Klassen zu den einzelnen Methoden navigieren.

Die vorangestellten Symbole indizieren die Art der dargestellten Objekte:

• M bedeutet Methode.

• C stellt eine Klasse dar.

• P ist eine Property.

• O bedeutet Outlet.

• V ist eine Instanzvariable (es sei denn, sie wurde z.B. bereits als Property deklariert).

• Pr ist ein Protokoll.

Die Darstellung ist hier hierarchisch oder flach möglich. Zudem bietet sich wieder am unteren Ende die Möglichkeit, nach Namen zu filtern oder nur bestimmte Symbole anzuzeigen.

3. Such-Navigator

Der Such-Navigator dient, wie der Name schon sagt, der Suche.

Abbildung 2-7: Der Such-Navigator

Hier können Sie global nach Zeichen oder Zeichenketten suchen und diese Suche auch durch verschiedene Optionen eingrenzen. Dabei gibt es die Möglichkeit, case-sensitive bzw. case-insensitive zu suchen oder die Suche auf ausgewählte Ordner oder Dateien innerhalb des Projekts zu begrenzen.

Abbildung 2-8: Ein Such-Pattern

Zudem lassen sich für Suchanfragen bestimmte Pattern definieren. Suchmuster hierfür sehen Sie in Abbildung 2-8.

4. Fehler-Navigator

Der Fehler-Navigator zeigt alle Warnungen (Warnings) oder Fehler (Errors) im Code in einer Übersicht an. Hier können Sie über das Auswählen der Fehler schnell zu ihnen navigieren bzw. können hier direkt Fix-its akzeptieren, um die Fehler zu beheben.

5. Test-Navigator

Im Test-Navigator werden alle von Ihnen erstellten Unit-Test-Methoden in hierarchischer Reihenfolge angezeigt. Nach Ausführung eines Tests wird Ihnen mithilfe von roten Fehler- oder grünen Erfolgs-Icons auch der Status dieses Tests angezeigt. Sie können über das Auswählen von Tests schnell zu den Methoden navigieren.

6. Debug-Navigator

Den Debug-Navigator werden Sie immer wieder zu Gesicht bekommen, wenn Sie mit der Fehlersuche bzw. dem Debugging beschäftigt sind.

Abbildung 2-9: Der Debug-Navigator

Wird die Applikation mithilfe eines Breakpoints gestoppt, wird das Navigationsfenster automatisch auf den Debugging-Bereich fokussiert. Hier sehen Sie zunächst den Status der Applikation, der eben an diesem Breakpoint pausiert, gefolgt von der aktuellen Hardwareauslastung.

Darunter sehen Sie eine hierarchische Darstellung der aktuellen Threads und erkennen, in welchem Sie gerade die Pause gesetzt haben. Diese Darstellung lässt sich über den Button in der oberen Zeile auch auf Queues und Views ändern.

7. Breakpoint-Navigator

Der Breakpoint-Navigator bietet eine Übersicht aller Breakpoints in hierarchischer Reihenfolge und den zugehörigen Klassen, wobei man diese hier auch aktivieren, deaktivieren und entfernen kann. Zudem gibt es unten verschiedene Filterfunktionen, etwa die Volltextsuche oder nur das Anzeigen aktiver Breakpoints. Über den Plus-Button lassen sich auch spezielle Breakpoints erstellen, wie Exception, Symbolic, OpenGL ES Error und Test Failure.

Die erste Handlung zum Projektstart sollte sein, einen Exception-Breakpoint zu erstellen. Dieser wird Ihnen bei Exceptions und Crashs stets anzeigen, an welcher Stelle diese auftreten.

8. Report-Navigator

Im Report-Navigator (oder auch Log-Navigator) lässt sich die Build-History des Projekts verfolgen. Hier sehen Sie auch, wann Build, Archive, Analyze oder Test stattfand. Zudem findet sich hier eine Log-Übersicht.

B – Der Editor

Der Editor ist primär das Text- bzw. Quellcodeeingabefenster der Entwicklungsumgebung, er dient aber auch als Anzeigebereich für sämtliche Funktionen, z.B. für den Interface Builder, Property Lists, Imageasset-Folders, Projekteinstellungen und diverse andere Formate. Da wir den Editor noch in einem der folgenden Abschnitte ausführlich beschreiben werden, möchten wir an dieser Stelle nur auf die Grundlagen eingehen.

Abbildung 2-10: Der Editor

Wie Sie in Abbildung 2-10 sehen, befindet sich oben eine Art Navigationsleiste für den Editor. Neben der browserähnlichen Vorwärts- und Rückwärtsnavigation gibt es einen Dateipfad, der Ihnen den aktuellen Bearbeitungsort angibt, darüber hinaus in einem Drop-down-Menü Methoden und Klassenabschnitte anzeigt und zur Schnellnavigation dient. Das geöffnete Menü gibt Ihnen einen Überblick über kürzlich verwendete Dateien, Klassen, vererbte Klassen und noch vieles mehr.

Der Editor verfügt über eine eigene Suchfunktion, die Sie mit dem Kürzel öffnen können. Diese ist auch um eine Search-and-replace-Funktion erweiterbar.

C – Der Debugging-Objektbaum

Der Objektbaum kann sehr nützlich sein, wenn Sie beim Debugging den Zustand und den Inhalt Ihrer Objekte während eines gestoppten Breakpoints überprüfen möchten.

Abbildung 2-11: Der Objektbaum

Wir haben in unserem Quellcode drei Variablen deklariert:

Beispiel 2-1: Debugging-Code

Nach der Berechnung der Variablen summe setzen wir einen Breakpoint. Wenn wir nun kompilieren und die Applikation zum gesetzten Breakpoint pausiert, sehen wir im Objektbaum eine Darstellung wie in Abbildung 2-11. Wir sehen vier Objekte:

• self

• zahl1

• zahl2

• summe

Hinter den Objekten stehen die zugewiesenen Werte. self steht hier für das Objekt bzw. die Klasse, in der wir den Code aktuell ausführen (ein UIViewController – das spielt aber für dieses Beispiel keine Rolle). Bei zahl1, zahl2 und summe finden wir hinter dem Zuweisungsoperator den Datentyp Int und den von uns zugewiesenen Wert.

Sie werden feststellen, dass gerade bei verschachtelten Arrays oder Dictionaries diese Funktion das Debugging deutlich vereinfacht.

Zudem stehen Ihnen in diesem Fenster noch einige Optionen zur Verfügung. So findet sich rechts unten eine Textbox, in der Sie im Volltext nach Objekten suchen können. Zusätzlich können Sie über den Info-Button ein ausgewähltes Objekt in der Konsole rechts neben dem Objektbaum ausgeben. Dieses Fenster und seine Funktionen werden Sie im nächsten Abschnitt kennenlernen. Das Augensymbol daneben dient dazu, direkt zum ausgewählten Objekt in den Quellcode zu springen. Neben ihm befindet sich noch eine Auswahlfunktion, mit der Sie den Debugger über eine Autofunktion selbst entscheiden lassen, ob er relevante Objekte anzeigt oder nur lokale Variablen sowie alle Variablen, Register, Globals oder Statics.

In der Navigationszeile über dem Objektbaum befindet sich die Debugging-Steuerung für Breakpoints. Wir definieren die Buttons von links nach rechts:

• Debugging-Fenster (Objektbaum und Konsole) sichtbar und unsichtbar machen

• Breakpoints aktivieren und deaktivieren

• pausiertes Programm wieder ausführen

• einen Schritt weiter (nur im pausierten Programm)

• Schritt rein

• Schritt raus

• Debug-Hierarchie anzeigen

• Geoposition simulieren

D – Die Debugging-Konsole

Die Konsole dient, ähnlich wie in anderen Entwicklungsumgebungen, nicht nur der Ausgabe von Systemlogs, sondern auch dazu, bestimmte Werte abzufragen, während die Applikation pausiert.

Abbildung 2-12: Die Konsole

Durch die Eingabe von po (print object) und des Variablennamens oder einer Speicheradresse können Sie, während die App pausiert, Werte auf der Konsole ausgeben lassen. Zusätzlich haben Sie Zugriff auf alle Properties des Objekts und können diese ebenfalls ausgeben lassen.

E – Das Utility-Fenster

Das Utility-Fenster nimmt den rechten Rand der Entwicklungsumgebung ein. Es spielt für die App-Entwicklung eine sehr bedeutende Rolle. Abhängig von der Umgebung – ob Editor oder Interface Builder – ändern sich die Aufgaben des Fensters. Wir werden vor allem in unserem praktischen Teil sehr häufig in diesem Bereich arbeiten.

F – Die Toolbar

Abbildung 2-13: Die Toolbar

In Abbildung 2-13 sehen Sie die Toolbar von Xcode 7. Hier befinden sich die Steuerungselemente für die Kompilierung, die Target- und Geräteauswahl, das Messageboard, die Editorfensterwahl sowie die Fensterauswahl-Buttons. Besonders diejenigen unter Ihnen, die schon ältere Versionen von Xcode kennen, werden feststellen, dass die Toolbar immer kompakter wird. Vor allem seit der Yosemite-Variante befinden sich die Buttons bereits auf derselben Höhe wie die Systemfenster-Buttons.

Wir gehen von links nach rechts: An erster Stelle befindet sich der Play-Button, mit dem das Projekt kompiliert und der Simulator bzw. das Gerät gestartet wird. Der Button verfügt darüber hinaus über ein Drop-down-Menü, das durch einen länger gehaltenen Mausklick geöffnet wird. In diesem Menü können Sie zusätzlich testen, profilen und analyzen. Daneben befindet sich der Stopp-Button, mit dem Sie den Simulator bzw. das Gerät stoppen können.

Als Nächstes folgt die Target-Auswahl, in deren Menü Sie auch die Möglichkeit haben, Schemes zu erstellen und zu bearbeiten. Ein Scheme ist eine Einstellungsauswahl, die sich auf ein oder mehrere bestimmte Targets bezieht. Darüber hinaus können Sie auch hier schon den Simulatortyp oder ein angeschlossenes Gerät auswählen. Diese Simulatorgeräteauswahl befindet sich nochmals direkt neben der Target-Auswahl.

In der Mitte der Toolbar sehen Sie das Messageboard, das neben einer Fortschrittsanzeige beim Kompilieren und Archivieren Laufzustände anzeigt und auch Hinweise auf etwaige Fehler bzw. Warnings ausgibt.

Rechts neben dem Messageboard befindet sich die erste von zwei Dreiergruppen mit Buttons. Hier können Sie die Fensterauswahl des Editors einstellen. So können Sie zwischen der Standardansicht und dem Assistent-Editor, in dem zwei Editierfenster nebeneinander dargestellt werden, sowie dem Versionseditor wechseln. Der Versionseditor, der in Projekten aktiv ist, die unter Versionsverwaltung stehen, verfügt wieder über ein Drop-down-Menü, das Sie mit einem länger gehaltenen Mausklick öffnen. In diesem Menü befinden sich drei Auswahlmöglichkeiten:

• Comparison

Eine Vergleichsansicht über zwei Editorfenster, in der man verschiedene Revisionen einer Datei vergleichen kann.

• Blame

Der gefürchtete Blame-View, der akkurat mit Zeitstempel angibt, welcher Entwickler wann welche Zeile Code geschrieben und committet hat.

• Log

Sehr ähnlich zum Blame-View, aber mit der Möglichkeit, in einem modalen Vergleichsfenster aktuelle Änderungen anzuzeigen.

Mit der letzten Dreiergruppe Buttons, die ganz rechts alle Funktionen der Toolbar abschließt, können Sie entscheiden, welche der vorhandenen Fenster Sie in Ihrer Entwicklungsumgebung sehen möchten. So können Sie das Navigations-, das Debugging- und das Utility-Fenster sichtbar oder unsichtbar machen.

Shortcuts, die das Leben erleichtern

Jeder Entwickler kennt und liebt seine Shortcuts. Auch Xcode verfügt über einige dieser nützlichen Tastenkürzel, die die Handhabung der Entwicklungsumgebung und das Arbeiten in ihr deutlich erleichtern. Da die Liste der Kürzel sehr lang ist und es für nahezu jede Funktion eine Tastenkombination gibt, werden wir uns hier auf die wesentlichen und aus unserer Sicht wirklich wichtigen konzentrieren. Dabei orientieren wir uns an dem deutschen Tastaturlayout.

Beginnen wir zunächst mit dem ersten Shortcut, der uns beim Start von Xcode und auch immer wieder als Navigationshilfe begegnen wird. Mit der Kombination öffnen wir das Willkommensfenster von Xcode, in dem wir nicht nur neue Projekte und Playgrounds anlegen, sondern auch eine Übersicht der aktuellen Projekte erhalten.

Das zentralste und wichtigste Kürzel aus unserer Sicht ist . Apple nennt diese Funktion Open Quickly, und das können wir nur bestätigen. Hiermit öffnen wir mittig auf dem Bildschirm ein Suchfenster – ähnlich dem Spotlight von Yosemite –, mit dem wir schnell zwischen Klassen, Property Lists, dem Interface Builder und anderen projektspezifischen Dateien wechseln können (siehe Abbildung 2-14).

Abbildung 2-14: Open Quickly

Selbstverständlich lassen sich in der Entwicklungsumgebung auch Tabs öffnen, ähnlich wie Sie das aus Safari kennen. Die Steuerung hierfür ist identisch; mit öffnen Sie einen Tab, und mit schließen Sie den aktuell sichtbaren wieder.

Auch beim Debugging unter Verwendung von Breakpoints kann es schnell zu Unterbrechungen kommen, da man z.B. vergessen hat, die Breakpoints zu entfernen oder zu deaktivieren. schafft Abhilfe, denn mit diesem Kürzel kann man Breakpoints schnell aktivieren bzw. deaktivieren.

Hiermit haben wir auch schon einige der gängigsten Shortcuts abgedeckt. Zum Abschluss führen wir noch ein paar nützliche Kürzel zur schnellen Codebearbeitung oder -erstellung im Editor auf:

• oder

An den Zeilenanfang bzw. ans Zeilenende springen.

• oder

Einzelne Wörter überspringen.

Mit zusätzlichem Halten von (z.B. ) kann man den übersprungenen Text auch markieren.

Eine ganze Zeile löschen.

Rückgängig machen.

Wiederherstellen.

Eine neue Datei erstellen.

In der aktuellen Klasse suchen.

Der Editor

Der Editor spielt die zentrale Rolle in der Entwicklungsumgebung, denn in ihm schreiben und lesen wir unseren Programmcode. Im Grunde genommen ist das Editorfenster ein ganz normaler Texteditor, der unter Xcode zusätzlich eine Autocompletion, Fehlermeldungen und Warnings mit gegebenenfalls angebotenen Fixit-Funktionen und einem Syntax-Highlighting anbietet (siehe Abbildung 2-15).

Abbildung 2-15: Der Editor

Wie wir oben bereits erwähnt haben, können Sie mithilfe der Buttons aus der Toolbar den Editor in verschiedenen Ansichten für unterschiedliche Funktionen nutzen. Ein Beispiel hierfür ist der Assistent-Editor, in dem Sie als Entwickler wunderbar parallel an zwei verschiedenen Klassen arbeiten können. Vor allem beim Verknüpfen von Storyboard-Elementen und Klassen (dazu später mehr) wird Ihnen hier eine angenehme Entwicklungsumgebung geboten.

Navigationsmöglichkeiten

Zusätzlich bietet der Editor Ihnen noch eine Reihe von Navigationsmöglichkeiten, die besonders beim schnellen Wechseln zwischen Klassen oder bei der Navigation und Funktionsübersicht innerhalb großer Klassen sehr hilfreich sein können (siehe Abbildung 2-16).

Abbildung 2-16: Navigationsmöglichkeiten 1

Zur besseren Übersicht und Navigation innerhalb des Projekts und einer Klasse können Sie über die sogenannte Jump Bar