Das Swift-Handbuch E-Book

Thomas Sillmann

• Herausgeber: Carl Hanser Verlag GmbH & Co. KG
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Deutsch

Seitenzahl: 1131

Veröffentlichungsjahr: 2026

Beschreibung

- Einsteiger:innen lernen die Grundlagen der Swift- Programmierung und wie sie Apps auf Basis von SwiftUI mit Xcode für die unterschiedlichen Plattformen entwickeln. - Profi s erfahren u. a., wie sie die Versionsverwaltung von Xcode nutzen und welches Vertriebsmodell das richtige für ihre App ist. - Basiert auf aktuellen Technologien wie SwiftUI, SwiftData und Swift Testing - Auf plus.hanser-fachbuch.de: Praxisprojekte zum Ausprobieren und Lernen als Download - Ihr exklusiver Vorteil: E-Book inklusive beim Kauf des gedruckten Buches Der unentbehrliche Begleiter für alle, die mit Swift und SwiftUI eigene Apps für die verschiedenen Apple-Plattformen entwickeln möchten. Von den Grundlagen über Listen und Navigationsstrukturen bis hin zum Umgang mit dem Status werden alle relevanten Themen der App-Entwicklung abgedeckt. Sie können das Buch als Nachschlagewerk für einzelne Funktionen verwenden, aber auch, um sich in neue Themen einzuarbeiten. Aufgrund des modularen Aufbaus finden Sie sich leicht zurecht. Die Programmiersprache Swift, die Entwicklungsumgebung Xcode und die Arbeit mit SwiftUI werden jeweils in einem eigenen Abschnitt behandelt. Das Buch richtet sich gleichermaßen an Einsteiger wie an Profis, die ihr Know-how in Bezug auf die App- Entwicklung für Apple-Plattformen ausbauen und vertiefen wollen. Ganz gleich, ob Sie neu mit der Programmierung in Swift durchstarten und die erste eigene App kreieren oder die Profi -Funktionen von Xcode beherrschen möchten: Das Swift-Handbuch ist Ihr idealer Wegbegleiter. AUS DEM INHALT // - Grundlagen der Swift-Programmierung - Speicherverwaltung mit ARC - Error Handling - Nebenläufi gkeit - Aufbau von Xcode - Debugging und Refactoring - App-Entwicklung für iOS, iPadOS, tvOS, visionOS und_watchOS - Grundlagen von SwiftUI - Liquid Glass - Views und View-Layout - Navigationsstrukturen - Status - Preview und Library - Persistente Datenspeicherung - Übersetzung von Apps - Versionsverwaltung - Unit-, UI- und Performance-Tests - Veröffentlichung im App Store - Business Models für Apps

Leseprobe

Ihr Plus – digitale Zusatzinhalte!

Auf plus.hanser-fachbuch.de gibt es kostenloses Zusatzmaterial zu diesem Buch.

Den Zugangscode finden Sie am Ende des Werkes.

Thomas Sillmann

Das Swift-Handbuch

Apps programmieren für alle Apple-Plattformen

5., aktualisierte Auflage

Der Autor:

Thomas Sillmann, Hösbach

[email protected]

Print-ISBN:        978-3-446-48502-0 E-Book-ISBN:   978-3-446-48513-6 E-Pub-ISBN:   978-3-446-48605-8

Die allgemein verwendeten Personenbezeichnungen gelten gleichermaßen für alle Geschlechter.

Alle in diesem Werk enthaltenen Informationen, Verfahren und Darstellungen wurden zum Zeitpunkt der Veröffentlichung nach bestem Wissen zusammengestellt. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Werk enthaltenen Informationen für Autor:innen, Herausgeber:innen und Verlag mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autor:innen, Herausgeber:innen und Verlag übernehmen infolgedessen keine Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Weise aus der Benutzung dieser Informationen – oder Teilen davon – entsteht. Ebenso wenig übernehmen Autor:innen, Herausgeber:innen und Verlag die Gewähr dafür, dass die beschriebenen Verfahren usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt also auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benützt werden dürften.

Die endgültige Entscheidung über die Eignung der Informationen für die vorgesehene Verwendung in einer bestimmten Anwendung liegt in der alleinigen Verantwortung des Nutzers.

Bibliografische Information der Deutschen Nationalbibliothek: Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet unter 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 Werkes, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Einwilligung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder einem anderen Verfahren), auch nicht für Zwecke der Unterrichtgestaltung – mit Ausnahme der in den §§ 53, 54 UrhG genannten Sonderfälle –, reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden. Wir behalten uns auch eine Nutzung des Werks für Zwecke des Text und Data Mining nach § 44b UrhG ausdrücklich vor.

© 2025 Carl Hanser Verlag GmbH & Co. KG, München Vilshofener Straße 10 | 81679 München | [email protected]: Sylvia Hasselbach, Kristin Rothe Herstellung: le-tex publishing services GmbH, Leipzig Copy editing: Walter Saumweber, Ratingen Coverkonzept: Marc Müller-Bremer, www.rebranding.de, München Covergestaltung: Thomas West Titelmotiv: © Max Kostopolus Satz: Eberl & Koesel Studio, Kempten Druck: Elanders Waiblingen GmbH, Waiblingen

„Bis zum Mond und wieder zurück haben wir uns lieb.“

Für meinen Vater

Wo Du auch bist, Du begleitest mich auf meiner Reise – bis zu jenem Tag, an dem wir uns wiedersehen und uns viele Geschichten erzählen werden.

Inhalt

Vorwort

Teil I: Swift

1 Die Programmiersprache Swift

1.1 Die Geschichte von Swift

1.2 Die Bedeutung von Swift im Apple-Kosmos

1.3 Das UI-Framework: SwiftUI

1.4 Was Sie als App-Entwickler brauchen

1.5 Programmieren für Beginner (und darüber hinaus): Playgrounds

1.6 Weitere wichtige Ressourcen

1.6.1 Apple-Developer-App

1.6.2 Apples Developer-Website

1.6.3 Swift.org

1.6.4 In eigener Sache

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

4.7.2 Prüfen, ob ein Dictionary leer ist

4.7.3 Anzahl der Schlüssel-Wert-Paare eines Dictionaries 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 Dictionaries auslesen und durchlaufen

4.8 Tuple

4.8.1 Zugriff auf die einzelnen Elemente eines Tuples

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

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 Property Wrapper

7.1.7 Type Property

7.2 Globale und lokale Variablen

7.3 Methoden

7.3.1 Instance Methods

7.3.2 Type Methods

7.4 Subscripts

7.5 Self

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 Closures

9.1 Closures als Parameter von Funktionen

9.2 Trailing Closures

9.3 Escaping Closures

9.4 Autoclosures

10 Vererbung

10.1 Überschreiben von Eigenschaften und Funktionen einer Klasse

10.2 Überschreiben von Eigenschaften und Funktionen einer Klasse verhindern

10.3 Zugriff auf die Superklasse

10.4 Initialisierung und Vererbung

10.4.1 Zwei-Phasen-Initialisierung

10.4.2 Überschreiben von Initializern

10.4.3 Vererbung von Initializern

10.4.4 Required Initializer

11 Speicherverwaltung mit ARC

11.1 Strong Reference Cycles

11.1.1 Weak References

11.1.2 Unowned References

11.1.3 Weak Reference vs. Unowned Reference

12 Weiterführende Sprachmerkmale von Swift

12.1 Nested Types

12.2 Extensions

12.2.1 Computed Properties

12.2.2 Methoden

12.2.3 Initializer

12.2.4 Subscripts

12.2.5 Nested Types

12.3 Protokolle

12.3.1 Deklaration von Eigenschaften und Funktionen

12.3.2 Der Typ eines Protokolls

12.3.3 Protokolle und Extensions

12.3.4 Vererbung in Protokollen

12.3.5 Class-Only-Protokolle

12.3.6 Optionale Eigenschaften und Funktionen

12.3.7 Protocol Composition

12.3.8 Delegation

12.3.9 Übersicht diverser vorhandener Protokolle

12.4 Key-Path

13 Type Checking und Type Casting

13.1 Type Checking mit „is“.

13.2 Type Casting mit „as“.

14 Error Handling

14.1 Deklaration und Feuern eines Fehlers

14.2 Reaktion auf einen Fehler

14.2.1 Mögliche Fehler mittels Do-Catch auswerten

14.2.2 Mögliche Fehler in Optionals umwandeln

14.2.3 Mögliche Fehler weitergeben

14.2.4 Mögliche Fehler ignorieren

15 Generics

15.1 Generic Functions

15.2 Generic Types

15.3 Type Constraints

15.4 Associated Types

16 Nebenläufigkeit

16.1 Asynchronen Code schreiben und aufrufen

16.2 Mehrere asynchrone Funktionen parallel ausführen

16.3 Priorität von Tasks festlegen

16.4 Ergebnisse über Task zurückliefern und auswerten

16.5 Tasks abbrechen

16.6 Ausführung von Tasks verzögern

16.7 Parent- und Child-Tasks

16.8 Actors

16.9 Main Actor

16.10 Sendable

17 Dateien und Interfaces

17.1 Modules und Source Files

17.2 Access Control

17.2.1 Access Level

17.2.2 Explizite und implizite Zuweisung eines Access Levels

17.2.3 Besonderheiten

Teil II: Xcode

18 Grundlagen, Aufbau und Einstellungen von Xcode

18.1 Über Xcode

18.2 Arbeiten mit Xcode

18.2.1 Dateien und Formate eines Xcode-Projekts

18.2.2 Umgang mit Dateien und Ordnern

18.3 Der Aufbau von Xcode

18.3.1 Toolbar

18.3.2 Navigator

18.3.3 Editor

18.3.4 Inspectors

18.3.5 Debug Area

18.4 Einstellungen

18.4.1 General

18.4.2 Apple Accounts

18.4.3 Intelligence

18.4.4 Behaviors

18.4.5 Navigation

18.4.6 Notifications

18.4.7 Themes

18.4.8 Editing

18.4.9 Shortcuts

18.4.10 Source Control

18.4.11 Components

18.4.12 Locations

18.5 Projekteinstellungen

18.5.1 Einstellungen am Projekt

18.5.2 Einstellungen am Target

18.5.3 Einstellungen am Scheme

19 Dokumentation, Devices und Organizer

19.1 Dokumentation

19.1.1 Aufbau und Funktionsweise

19.1.2 Direktzugriff im Editor

19.2 Devices und Simulatoren

19.2.1 Simulatoren

19.2.2 Devices

19.3 Organizer

20 Debugging und Refactoring

20.1 Debugging

20.1.1 Einfache Konsolenausgaben

20.1.2 Logging

20.1.3 Arbeiten mit Breakpoints

20.1.4 Debug Navigator

20.2 Refactoring

20.3 Instruments

21 Tipps und Tricks für das effiziente Arbeiten mit Xcode

21.1 Code Snippets

21.2 Open Quickly

21.3 Related Items

21.4 Navigation über die Jump Bar

21.5 MARK, TODO und FIXME

21.6 Runtime-Bedingungen

21.7 Shortcuts für den Navigator

21.8 Clean Build

21.9 Coding Assistant

21.10 Playgrounds

21.10.1 Was sind Playgrounds?

21.10.2 Code schreiben und testen

21.10.3 Dateien hinzufügen

21.10.4 Kommentare und Dokumentation

21.10.5 Swift Playgrounds-App

Teil III: App-Entwicklung

22 Grundlagen der App-Entwicklung

22.1 Die Basis: SwiftUI

22.2 Bestandteile einer App

22.2.1 Umsetzung der Daten

22.2.2 Umsetzung der Ansichten

22.2.3 Weitere Frameworks

22.3 Das Design: Liquid Glass

22.4 Die Syntax von SwiftUI

22.5 Aufbau einer App

22.6 Das View-Protokoll

22.7 Aktualisierung von Views mittels Status

22.8 Grundlagen des Status

22.9 Anpassung von Views mittels Modifier

22.10 Gruppierung von Views mittels Containern

22.11 Praxis: Unsere erste App

22.11.1 Bestandteile des neuen Projekts

22.11.2 Änderung des Textes

22.11.3 Einsatz der Preview

23 Views in SwiftUI

23.1 Textdarstellung und -bearbeitung

23.1.1 Text

23.1.2 TextField

23.1.3 SecureField

23.1.4 TextEditor

23.2 Bilder

23.2.1 Image-Instanz erstellen

23.2.2 Größe einer Image-Instanz ändern

23.3 Schaltflächen

23.3.1 Button

23.3.2 EditButton

23.3.3 PasteButton

23.4 Werteauswahl

23.4.1 Toggle

23.4.2 Slider

23.4.3 Stepper

23.4.4 Picker

23.4.5 DatePicker

23.4.6 MultiDatePicker

23.4.7 ColorPicker

23.5 Weitere Views

23.5.1 Label

23.5.2 ProgressView

23.5.3 Gauge

24 View-Layout

24.1 Stacks

24.1.1 HStack

24.1.2 VStack

24.1.3 ZStack

24.1.4 Stacks verschachteln

24.1.5 Lazy Stacks

24.2 Listen

24.2.1 List

24.2.2 ForEach

24.3 Grids

24.3.1 Grid

24.3.2 LazyHGrid und LazyVGrid

24.4 Table

24.4.1 Zellen selektieren

24.4.2 Sortierung ändern

24.5 Container-Views

24.5.1 Form

24.5.2 Section

24.5.3 Group

24.5.4 GroupBox

24.5.5 ViewThatFits

24.6 Weitere Views

24.6.1 ScrollView

24.6.2 OutlineGroup

24.6.3 DisclosureGroup

24.6.4 Spacer

24.6.5 Divider

25 Navigation

25.1 NavigationStack und NavigationLink

25.1.1 Titel in Navigation-Bar setzen

25.1.2 Eigene View zur Darstellung eines NavigationLink nutzen

25.1.3 Anzeige einer Ziel-View auf Basis von Daten

25.1.4 Programmatische Steuerung des Navigation-Stacks

25.2 NavigationSplitView

25.2.1 Verknüpfung von NavigationSplitView und List

25.2.2 Sichtbarkeit der Spalten steuern

25.2.3 Breite der Spalten anpassen

25.2.4 Verhalten von NavigationSplitView unter den verschiedenen Apple-Plattformen

25.3 TabView

25.4 HSplitView und VSplitView

25.5 Funktionen zur Präsentation von Views

25.5.1 Sheet einblenden

25.5.2 View über gesamtes Fenster legen

25.5.3 Popover einblenden

26 Weitere View-Konfigurationen

26.1 Toolbar

26.2 Alerts

26.3 Confirmation Dialog

26.4 Farben

26.5 View-Events

26.6 Eigene Modifier umsetzen und aufrufen

27 Status

27.1 Property

27.2 State

27.3 Binding

27.4 ObservedObject

27.4.1 Datenmodell vorbereiten

27.4.2 Datenmodell in View einbinden

27.4.3 Auf Änderungen reagieren

27.5 StateObject

27.6 EnvironmentObject

27.7 @Observable-Makro und Bindable

27.8 Environment

27.9 SceneStorage

27.10 AppStorage

27.11 Source of Truth vs. Derived Value

27.12 Best Practices

28 Datenhaltung

28.1 UserDefaults

28.1.1 UserDefaults und SwiftUI

28.2 SwiftData

28.2.1 Grundlegende Funktionsweise von SwiftData

28.2.2 Erstellen des eigenen Datenmodells

28.2.3 Model-Container erzeugen

28.2.4 Elemente im ModelContext verwalten

28.2.5 Zusammenspiel mit der Preview

28.3 Core Data

28.3.1 Grundlegende Funktionsweise von Core Data

28.3.2 Grundlegende Elemente beim Einsatz von Core Data

28.3.3 Einen Core Data Stack erstellen

28.3.4 Ein Managed Object Model erstellen

28.3.5 Grundlegende Core-Data-Operationen

28.3.6 Core Data mit SwiftUI

29 Weitere Projektkonfigurationen

29.1 Cross-Platform-Entwicklung

29.1.1 Neue Targets hinzufügen

29.1.2 Target-Zuweisung

29.1.3 Plattform im Code prüfen

29.1.4 Funktionen auf Verfügbarkeit prüfen

29.2 Mehrsprachigkeit

29.2.1 Grundlagen

29.2.2 Verschiedene Sprachen einer App testen

29.3 Asset Catalogs

30 Preview und Library

30.1 Preview

30.1.1 Funktionsweise der Preview

30.1.2 Konfiguration der Preview

30.1.3 Preview ausführen und anhalten

30.2 Library

Teil IV: Source Control und Testing

31 Source Control

31.1 Basisfunktionen und -begriffe der Source Control

31.2 Source Control in Xcode

31.2.1 Bestehendes Projekt klonen

31.2.2 Lokale Änderungen committen

31.2.3 Lokale Änderungen verwerfen

31.2.4 Pull und Push

31.2.5 Aktuelle Branches vom Repository laden

31.2.6 Git-Repository mit neuem Xcode-Projekt erzeugen

31.2.7 Optische Source-Control-Hervorhebungen im Editor

31.2.8 Zugriff auf GitHub, GitLab und Bitbucket

31.3 Source Control Navigator

31.4 Code Review Mode

32 Testing

32.1 Unit-Tests

32.1.1 Unit-Tests mit Swift Testing

32.1.2 Unit-Tests mit XCTest

32.1.3 Neue Test-Datei erstellen

32.1.4 Ausführen von Unit-Tests

32.2 Performancetests

32.3 UI-Tests

32.3.1 Klassen für UI-Tests

32.3.2 Aufbau von UI-Test-Klassen

32.3.3 Automatisches Erstellen von UI-Tests

32.3.4 Einsatz von UI-Tests

Teil V: Veröffentlichung von Apps

33 Veröffentlichung im App Store

33.1 Das Apple Developer Portal

33.1.1 Zertifikate, App IDs und Provisioning Profiles

33.1.2 Code Signing

33.2 App Store Connect

33.2.1 Apps für den App Store vorbereiten und verwalten

33.2.2 Apps erstellen, hochladen und einreichen

33.3 App Store Review Guidelines

34 Das Business Model für Ihre App

34.1 Geschäftsmodelle

34.1.1 Free Model

34.1.2 Freemium Model

34.1.3 Subscription Model

34.1.4 Paid Model

34.1.5 Paymium Model

34.2 App Bundles

34.3 Veröffentlichung außerhalb des App Store

34.3.1 Das Apple Developer Enterprise Program

35 TestFlight

35.1 TestFlight in App Store Connect

35.2 TestFlight im App Store

Vorwort

Herzlich Willkommen in der Welt von Swift, Apples hauseigener Programmiersprache zur Entwicklung von Apps für iPhone, iPad, Mac und Co.! Da Sie dieses Buch in Händen halten, mutmaße ich, dass Sie mehr über die Programmierung für Apple-Plattformen erfahren oder Ihre ersten Schritte in dieser faszinierenden Welt bestreiten möchten.

Bevor ich Sie in die Welt der Programmierung entführe, möchte ich dieses Vorwort dazu nutzen, einige grundlegende Worte über den Aufbau und die Inhalte dieses Buches zu verlieren. Das soll Ihnen als erste Übersicht und weiterer Wegweiser dienen, um bestmöglich mit dem Buch arbeiten zu können und schnelle Erfolge bei der Programmierung zu erzielen.

Inhalte

Das Buch basiert auf der im Herbst 2025 erschienenen Version 6.2 von Swift sowie der Version 26 der Entwicklungsumgebung Xcode. Alle Kapitel der vorherigen Auflage wurden entsprechend aktualisiert sowie um neue Inhalte ergänzt. Hierzu gehören Infos bezüglich Liquid Glass und der aktualisierten SwiftUI-Views, ausgebaute Informationen zum Einsatz von Swift Testing sowie kleinere Ergänzungen beispielsweise zu Self und zu Swift Concurrency.

Generell schlägt diese fünfte Auflage des Swift-Handbuchs inhaltlich den gleichen Weg ein wie die vorherigen Auflagen. Der Fokus liegt klar auf den drei wichtigsten Elementen für die App-Entwicklung für iOS, iPadOS, macOS, tvOS, visionOS und watchOS:

       Die Programmiersprache Swift

       Die Entwicklungsumgebung Xcode

       Die App-Entwicklung mit SwiftUI

Insbesondere SwiftUI ist in dieser Auflistung hervorzuheben. Seit der erstmaligen Vorstellung im Jahr 2019 hat sich SwiftUI massiv weiterentwickelt und bietet inzwischen eine Vielzahl an Möglichkeiten zur Umsetzung und Gestaltung von Apps.

Dieses Handbuch liefert Ihnen handfestes Wissen zu allen drei genannten Bereichen. So lernen Sie die Programmiersprache Swift und ihre verschiedenen Sprachfeatures kennen. Sie erfahren, wie die Entwicklungsumgebung Xcode aufgebaut ist und welche Funktionen Ihnen bei der täglichen Entwicklerarbeit zur Verfügung stehen. Und Sie erhalten einen Überblick über die Möglichkeiten, die Sie zur Gestaltung von Apps mit SwiftUI nutzen können. Darüber hinaus finden Sie auch Kapitel zur Versionsverwaltung und zum Testing sowie zur Veröffentlichung von Apps im App Store.

Kurzum: Dieses Handbuch soll Ihnen als Grundlage dienen, um einen Überblick über die wichtigsten Bereiche der App-Entwicklung für Apple-Plattformen zu erhalten und Ihnen das nötige Verständnis vermitteln, um das erlangte Wissen in eigenen Projekten zum Einsatz bringen zu können.

Aufbau des Buches

Mir ist es wichtig, dass Sie das Buch als Referenzwerk nutzen können. Entsprechend finden Sie je einen eigenen Teil zur Programmiersprache Swift, zur Entwicklungsumgebung Xcode sowie zur App-Entwicklung mit SwiftUI. Das ermöglicht es Ihnen, sich separat mit diesen drei Bestandteilen auseinanderzusetzen und notwendige Infos zu erhalten, ohne diese Inhalte im Buch zu vermischen.

Ich möchte Sie in die Lage versetzen, eigene Apps entwickeln zu können. Zu diesem Zweck halte ich die Code-Beispiele im Buch bewusst klein und setze nicht auf die Umsetzung ganzer Projekte. Stattdessen sollen Sie das nötige Wissen erlangen, um Ihre eigenen Anwendungen erstellen zu können und zu diesem Zweck alles über die dafür notwendigen Komponenten erfahren.

Ein solches Grundverständnis erlaubt es Ihnen außerdem, sich selbstständig in weitere Bereiche einzuarbeiten und künftige Neuerungen mithilfe der Dokumentation anzuwenden.

Beispielprojekte auf Hanser-Plus

Über Hanser-Plus stehen Ihnen kleine Beispielprojekte zum Download zur Verfügung, die einzelne Aspekte der App-Entwicklung und der Programmierung mit Swift beleuchten. Diese Beispiele sind bewusst überschaubar gehalten, um den Fokus auf grundlegende Funktionsweisen zu richten und Ihnen einen verständlichen Überblick zu verschaffen. Nutzen Sie diese Beispiele gerne, um darauf aufbauend selbst ein wenig im Code zu experimentieren oder um zu überprüfen, wie sich bestimmte Funktionen umsetzen lassen. Um die Beispiele herunterzuladen, geben Sie auf der Webseite https://plus.hanser-fachbuch.de/ den Code ein, den Sie hinten im Buch finden.

Feedback

In diesem Sinne wünsche ich Ihnen nun viel Freude mit dem Buch und Erfolg beim Programmieren. Sollten Sie Feedback zum Buch haben, können Sie mich gerne via E-Mail an

[email protected]

kontaktieren.

Ich bin inzwischen seit über zehn Jahren begeisterter Entwickler für die verschiedenen Apple-Plattformen. Ich finde das Apple-Ökosystem, die Programmiersprache Swift und die Entwicklungsumgebung Xcode faszinierend und arbeite jeden Tag voller Begeisterung damit. Ich hoffe, dass ich mit diesem Buch einen Teil meiner Begeisterung auch auf Sie übertragen kann.

Thomas Sillmann

Juli 2025

Teil I: Swift

Kapitel 1: Die Programmiersprache Swift

Kapitel 2: Grundlagen der Programmierung

Kapitel 3: Schleifen und Abfragen

Kapitel 4: Typen in Swift

Kapitel 5: Funktionen

Kapitel 6: Enumerations, Structures und Classes

Kapitel 7: Eigenschaften und Funktionen von Typen

Kapitel 8: Initialisierung

Kapitel 9: Closures

Kapitel 10: Vererbung

Kapitel 11: Speicherverwaltung mit ARC

Kapitel 12: Weiterführende Sprachmerkmale von Swift

Kapitel 13: Type Checking und Type Casting

Kapitel 14: Error-Handling

Kapitel 15: Generics

Kapitel 16: Nebenläufigkeit

Kapitel 17: Dateien und Interfaces

1Die Programmiersprache Swift

Nach dem Vorwort heiße ich Sie nun an dieser Stelle ein weiteres Mal recht herzlich willkommen in der faszinierenden Welt von Swift. Bevor es im zweiten Kapitel konkret mit der Programmierung losgeht, möchte ich Ihnen an dieser Stelle etwas über die Geschichte von Swift, die Bedeutung der Sprache im Apple-Kosmos sowie die Tools erzählen, die für uns als Entwickler unabdingbar sind.

1.1Die Geschichte von Swift

Keine Bange, das soll hier keine langatmige monotone Geschichtsstunde werden. Falls es Sie auch nicht im Geringsten interessieren sollte, wie Swift entstanden ist, dürfen Sie diesen Abschnitt guten Gewissens gerne überspringen; ich wäre Ihnen nicht böse deswegen. Obwohl ich den Hintergrund, wie Swift das Licht der Welt erblickte, durchaus spannend finde.

Dabei sind viele Details über die genaue Entstehungsgeschichte von Swift gar nicht bekannt. Was man weiß, ist, dass Chris Lattner wohl in gewisser Weise als „Vater“ von Swift bezeichnet werden kann. Er begann die Entwicklung von Swift im Juli 2010 bei Apple aus eigenem Antrieb heraus und zunächst im Alleingang. Ab Ende 2011 kamen dann weitere Entwickler dazu, während 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.1).

Bild 1.1Auf 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.

Im darauffolgenden Jahr sorgte Apple auf der WWDC 2015 dann für die nächste große Überraschung. Sie präsentierten nicht nur 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 , um darüber zukünftig alle Weiterentwicklungen und Neuerungen zu Swift zusammenzutragen.

Seitdem hat die Sprache viele weitere Versionssprünge hinter sich und sie entwickelt sich noch immer stetig weiter. Einen großen Beitrag leistet hierbei auch die große Swift-Community, die mögliche Neuerungen und Änderungen vorantreibt.

Heute ist Swift die Sprache der Wahl, wenn es um die Entwicklung von Apps für Apple-Plattformen geht. Darüber hinaus findet Swift aber auch auf immer mehr Systemen wie Linux oder Windows Verwendung, ist dort aber bei weitem nicht so verbreitet wie im Apple-Umfeld.

1.2Die Bedeutung von Swift im Apple-Kosmos

Aus Sicht von Apple ist eines ganz offensichtlich: Swift gehört die Zukunft. Zwar unterstützt Apple noch immer die „alte“ Programmiersprache Objective-C, doch die wird im Gegensatz zu Swift kaum bis gar nicht weiterentwickelt.

Auch ist Swift in bestimmten Bereichen der App-Entwicklung inzwischen ein Muss. Manche Systemfunktionen lassen sich nur mit Swift und nicht mit Objective-C ansteuern. So zeigt Apple auf sehr drastische Art und Weise, welcher Programmiersprache Entwickler ihre Aufmerksamkeit widmen sollten.

Zwar gibt es noch sehr viel Objective-C-Code da draußen und sicherlich diverse Entwickler-Kollegen, die Objective-C im Vergleich zu Swift klar bevorzugen. Doch es ändert nichts daran, dass Swift die Zukunft gehört, und danach sollten auch wir Entwickler uns richten.

Und wenn ich hier persönlich werden darf: In meinen Augen ist Swift nicht nur eine äußerst mächtige und vielseitige, sondern auch wunderschön zu schreibende Programmiersprache. Mit modernen Ansätzen erleichtert sie außerdem Neulingen den Einstieg, und ich behaupte einmal, dass diese Aussage jeder unterschreiben kann, der bereits einmal mit Objective-C entwickelt hat.

Auch Swift mag nicht perfekt sein, doch die Entwicklung der letzten Jahre zeigt, dass die Sprache auf einem verdammt guten Weg ist und sowohl von Apple als auch der Open-Source-Community sehr viel Pflege erfährt.

Es mag abgedroschen klingen, doch jetzt ist definitiv der beste Zeitpunkt, sich der Programmierung mit Swift zu widmen.

1.3Das UI-Framework: SwiftUI

In Teil 3 dieses Buches, der sich vollumfassend den spezifischen Besonderheiten der App-Entwicklung widmet, werden Sie sehr sehr viel über SwiftUI lesen. Bei SwiftUI handelt es sich um ein sogenanntes Framework. Frameworks setzen sich aus einem Set verschiedener Funktionen zusammen, die Sie als App-Entwickler nutzen können, wenn Sie das Framework in Ihr App-Projekt einbinden.

Auch wenn SwiftUI nicht direkt etwas mit der Programmiersprache Swift zu tun hat, möchte ich an dieser Stelle ein paar Worte darüber verlieren. Das hängt nämlich mit einer grundsätzlichen Verständnisfrage zusammen, auf die ich in den letzten Jahren öfters gestoßen bin. So gilt:

Swift ist eine Programmiersprache. SwiftUI ist ein Framework, das auf Swift basiert und spezielle Funktionen für die Erstellung von Nutzeroberflächen zur Verfügung stellt.

Wenn Sie also die Begriffe Swift und SwiftUI hören, geht es nicht darum, welches der beiden Sie verwenden sollen. Wenn Sie SwiftUI einsetzen, kommen Sie um ein Verständnis der Programmiersprache Swift gar nicht herum, denn darauf basiert SwiftUI nun einmal. Doch beschränkt sich der Einsatz von Swift nicht nur auf die Entwicklung von Nutzeroberflächen. So gesehen benötigen Sie Swift immer. Es ist die grundlegendste Säule der App-Entwicklung.

Wie gesagt, finden Sie in Teil 3 des Buches weitreichende Informationen zur Nutzung und Funktionsweise von SwiftUI.

1.4Was Sie als App-Entwickler brauchen

Um mit Swift Ihre eigenen Apps für iPhone, iPad und Co. entwickeln zu können, führt in der Regel kein Weg an Apples hauseigener Entwicklungsumgebung Xcode vorbei (warum ich hier „in der Regel“ schreibe, erläutere ich noch).

Xcode ist eine App, die exklusiv auf dem Mac zur Verfügung steht und die Sie kostenlos und bequem aus dem Mac App Store herunterladen und installieren können (siehe Bild 1.2).

Bild 1.2Xcode ist Apples vollwertige Entwicklungsumgebung für die Programmierung von Apps.

Xcode bringt alles mit, was Sie für die App-Entwicklung benötigen. Dazu gehört auch Unterstützung für Swift und SwiftUI. Außerdem verfügt Xcode über verschiedene Simulatoren, die es Ihnen beispielsweise ermöglichen, iPhone-Apps direkt auf Ihrem Mac auszuführen und zu testen.

Mithilfe von Xcode erstellen Sie Projekte für Ihre Apps und verwalten darin sowohl den Quellcode als auch weitere Ressourcen wie Bilder. Xcode kann Ihnen darüber hinaus beim Auffinden von Fehlern in Ihrer App helfen und ermöglicht es sogar, Ihre fertige App direkt in den App Store hochzuladen. Mehr zur Veröffentlichung von Apps erfahren Sie im letzten Teil dieses Buches.

Aufgrund dieses großen Funktionsumfangs kann Xcode als durchaus komplexe Anwendung angesehen werden. Das gilt umso mehr, wenn man zuvor noch keinerlei Programmiererfahrung gesammelt hat. Aus diesem Grund liefert Ihnen der zweite Teil dieses Buches einen Rundumüberblick über den Aufbau und die verschiedenen Bestandteile von Apples Entwicklungsumgebung.

Die abgespeckte Xcode-Alternative: Swift Playgrounds

Ich habe ja zu Beginn dieses Abschnitts geschrieben, dass zur App-Entwicklung „in der Regel“ kein Weg an Xcode vorbeiführt. Tatsächlich gibt es für das iPad eine Alternative zur vollwertigen Entwicklungsumgebung auf dem Mac: die App Swift Playgrounds (siehe Bild 1.3).

Bild 1.3Swift Playgrounds ermöglicht das Programmieren auch auf Apples iPad.

Swift Playgrounds entstand ursprünglich, um Nutzern die Grundlagen der Programmierung spielerisch näherzubringen. Diese Funktion besitzt die App auch heute noch und sie ist definitiv einen Blick wert. Zusätzlich ermöglicht sie es inzwischen aber auch, vollwertige Apps für iPhone und iPad mit ihr zu entwickeln und direkt in den App Store hochzuladen.

Das ist definitiv eine großartige Sache, doch sollte man sich keinen Illusionen hingeben: Für die professionelle Entwicklung von Apps ist noch immer Xcode das Mittel der Wahl. Xcode bietet deutlich mehr Funktionen und Möglichkeiten als Swift Playgrounds. Dafür erlaubt es Swift Playgrounds, Apps nicht nur auf dem Mac, sondern auch auf Apples iPad zu entwickeln.

Übrigens: Für die App-Entwicklung unterstützt Swift Playgrounds ausschließlich die Programmiersprache Swift sowie das neue UI-Framework SwiftUI. Das ist also ein klarer Grund mehr, sich heute ausgiebig mit diesen beiden so wichtigen Technologien für Apple-Entwickler auseinanderzusetzen.

1.5Programmieren für Beginner (und darüber hinaus): Playgrounds

Wenn es um die Entwicklung von Apps geht, arbeitet man in sogenannten Projekten. In diesen verwaltet man neben dem Quellcode auch alle zusätzlichen Ressourcen wie Bilder. Außerdem enthält solch ein Projekt weitere Informationen wie die Versionsnummer und die Unterstützung für optionale Services (beispielsweise iCloud).

Gerade am Anfang erhält man mit solch einem Projekt von Haus aus bereits sehr viele Dateien, die einen gerade als Anfänger überfordern können. Außerdem möchte man in manchen Fällen auch einfach einmal ein wenig mit Swift experimentieren, ohne dafür gleich ein ganzes Projekt erzeugen zu müssen.

Abhilfe schaffen hier die sogenannten Playgrounds (siehe Bild 1.4). In einem Playground können Sie einfach Code drauflos schreiben, ohne sich mit Projektstrukturen und dem Ablauf Ihrer App beschäftigen zu müssen. Per Klick auf einen Button führen Sie den Code aus und sehen umgehend dessen Ergebnis.

Gerade zu Beginn ist es absolut sinnvoll, Ihren Code in Playgrounds zu schreiben und zu testen. So machen Sie sich schnell mit den Grundlagen und der Syntax von Swift vertraut, ohne von den genannten Projektstrukturen ganzer Apps womöglich überfordert zu werden.

Bild 1.4Playgrounds sind ein ideales Mittel, um zu experimentieren und das Programmieren zu lernen.

Gerade wenn Sie bisher nur wenig oder gar keine Erfahrung mit Swift gesammelt haben, empfehle ich Ihnen, die Beispiele in diesem ersten Teil des Buches mithilfe von Playgrounds ebenfalls zu programmieren. Nutzen Sie die Flexibilität von Playgrounds, um ruhig auch selbst zu experimentieren und Dinge auszuprobieren, die Sie interessieren oder die Ihnen in den Sinn kommen. Besser kann man sich mit der Programmierung gar nicht vertraut machen!

Übrigens sind Playgrounds nicht nur ein ideales Mittel, um das Programmieren grundlegend zu lernen. Auch Profis nutzen sie, um sich bequem mit neuen Frameworks oder der Umsetzung einer komplexen Programmlogik auseinanderzusetzen. Entwickler können so Ihren Code unabhängig von einem vollständigen und meist komplexen App-Projekt testen. Hat man eine passende Lösung erarbeitet, kann man diese anschließend in das eigentliche Projekt übertragen.

Mehr zur Verwendung von Playgrounds und wie Sie solche mit Xcode erstellen, erfahren Sie im zweiten Teil dieses Buches.

Swift Playgrounds auf dem iPad

Sie können Playgrounds auch auf dem iPad erstellen und so auf Apples Tablet programmieren. Zu diesem Zweck steht Ihnen eine App mit dem passenden Namen Swift Playgrounds zur Verfügung, die Sie kostenlos aus dem App Store laden können (siehe auch Abschnitt 1.4, „Was Sie als App-Entwickler brauchen“).

Die App eignet sich auch ideal für Einsteiger, die das Programmieren lernen möchten. Sie finden darin verschiedene kleine Lernkurse, die spielerisch die Grundlagen der Entwicklung mit Swift vorstellen. Darüber hinaus können Sie mit der App aber auch die eben beschriebenen Playgrounds erstellen und so ganz frei mit Code und dem Programmieren experimentieren.

Übrigens steht die Swift-Playgrounds-App auch als dedizierte Anwendung auf dem Mac zur Verfügung, unabhängig von Xcode. Falls Sie die genannten Lernkurse daher auch auf dem Mac ausprobieren möchten, können Sie das über die Swift-Playgrounds-App tun. Wenn Sie aber erst einmal näher mit der Swift-Programmierung und der Entwicklungsumgebung Xcode vertraut sind, benötigen Sie die App nicht wirklich auf dem Mac. Xcode liefert Ihnen alles, was Sie brauchen, um Ihre eigenen Anwendungen umzusetzen und Code in separaten Playgrounds zu testen.

1.6Weitere wichtige Ressourcen

In der Welt der App-Entwicklung gibt es keinen Stillstand. In mehr oder weniger regelmäßigen Abständen erscheinen neue Versionen von Programmiersprachen, Entwicklungsumgebungen und Betriebssystemen. Manche dieser Updates verbessern lediglich die Stabilität oder ergänzen praktische neue Funktionen. Andere wiederum ersetzen bekannte Mechanismen durch neue. Entsprechend wichtig ist es, als Entwickler up to date zu sein.

Erfreulicherweise gibt es diverse Ressourcen, über die Sie sich auf dem Laufenden halten können. Nachfolgend möchte ich Ihnen einige davon vorstellen, die ich selbst als regelmäßige Anlaufstellen nutze.

1.6.1Apple-Developer-App

Für macOS, iOS, tvOS und visionOS stellt Apple eine kostenlose Developer-App zur Verfügung (siehe Bild 1.5). Darin finden Sie eine Vielzahl an Videos und diverse Artikel, die spezifische Aspekte der App-Entwicklung erläutern.

Bild 1.5Apples offizielle Developer-App ist die ideale Ergänzung für alle Entwickler.

Insbesondere erhalten Sie über die App Zugriff auf die verschiedenen Session-Videos, die Apple im Zuge seiner alljährlichen Entwicklerkonferenz (Worldwide Developers Conference, kurz WWDC) veröffentlicht. Eine bessere Möglichkeit, sich über die neuesten Techniken im Bereich Swift, iOS und Co. zu informieren, gibt es wohl nicht.

1.6.2Apples Developer-Website

Eine zentrale Anlaufstelle für alle Apple-Entwickler stellt Apples offizielle Developer-Website dar, die Sie mittels des Links https://developer.apple.com erreichen (siehe Bild 1.6). Sie liefert Ihnen eine Übersicht über die neuesten Entwicklungen und ermöglicht den Zugriff auf Beta-Versionen von iOS und Co. Über diese Website erstellen Sie zudem Ihren eigenen Entwickler-Account und können auf verschiedene Ressourcen wie Zertifikate und App-IDs zurückgreifen. Mehr zu diesen Möglichkeiten erfahren Sie im letzten Teil dieses Buches.

Bild 1.6Über Apples offizielle Entwickler-Website haben Sie Zugriff auf aktuelle Infos und Beta-Versionen.

1.6.3Swift.org

Wenn Sie sich im Speziellen für die Programmiersprache Swift interessieren, ist die offizielle Website http://swift.org genau das richtige (siehe Bild 1.7). Neben grundlegenden Informationen zu Swift finden Sie dort auch eine vollständige Dokumentation sowie einen Blog, der über kommende Updates und Änderungen der Sprache informiert. Vorbeischauen lohnt sich!

Bild 1.7Die geballte Ladung Swift gibt es auf der offiziellen Website der Sprache unter swift.org.

1.6.4In eigener Sache

Sie finden unter

https://letscode.thomassillmann.de

meinen ganz persönlichen Entwickler-Blog. Dort veröffentliche ich in unregelmäßigen Abständen neue Beiträge rund um die App-Entwicklung für Apple-Plattformen. Außerdem gibt es auf meinem YouTube-Kanal unter

https://www.youtube.com/user/Sillivan1988

regelmäßig neue Videos zur App-Entwicklung.

2Grundlagen der Programmierung

3Schleifen und Abfragen