59,99 €
Mehr erfahren.
- Herausgeber: Carl Hanser Verlag GmbH & Co. KG
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Deutsch
- Veröffentlichungsjahr: 2025
- Einsteiger lernen die Grundlagen der Swift-Programmierung und wie sie Apps auf Basis von SwiftUI mit Xcode für die unterschiedlichen Plattformen entwickeln.
- Profis 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. Hier werden von den Grundlagen über Listen und Navigationsstrukturen bis hin zum Umgang mit dem Status 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 ob Sie 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äufigkeit
- Aufbau von Xcode
- Debugging und Refactoring
- App-Entwicklung für macOS, iOS, watchOS und tvOS
- Grundlagen von SwiftUI
- 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
Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:
Seitenzahl: 1135
Ähnliche
Thomas Sillmann
Das Swift-Handbuch
Apps programmieren für macOS, iOS, watchOS und tvOS
4., aktualisierte Auflage
Ihr Plus – digitale Zusatzinhalte!
Auf unserem Download-Portal finden Sie zu diesem Titel kostenloses Zusatzmaterial.
Geben Sie auf plus.hanser-fachbuch.de einfach diesen Code ein:
plus-Mn39r-24KpS
Der Autor: Thomas Sillmann, [email protected]
Print-ISBN: 978-3-446-48080-3E-Book-ISBN: 978-3-446-48142-8E-Pub-ISBN: 978-3-446-48355-2
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.
Aus Gründen der besseren Lesbarkeit wird auf die gleichzeitige Verwendung der Sprachformen männlich, weiblich und divers (m/w/d) verzichtet. Sämtliche Personenbezeichnungen gelten gleichermaßen für alle Geschlechter.
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ünchenKolbergerstraße 22 | 81679 München | [email protected]: Sylvia HasselbachCopy editing: Walter Saumweber, RatingenCoverkonzept: Marc Müller-Bremer, www.rebranding.de, MünchenCovergestaltung: Thomas WestTitelmotiv: Thomas West, unter Verwendung von Grafiken von © Max KostopoulosHerstellung: le-tex publishing services GmbH, LeipzigSatz: Eberl & Koesel Studio, Kempten
„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 wiedersehenund uns viele Geschichten erzählen werden.
Inhalt
Titelei
Impressum
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
5.5 Closures
5.5.1 Closures als Parameter von Funktionen
5.5.1.1 Implicit Return
5.5.1.2 Shorthand Argument Names
5.5.2 Trailing Closures
5.5.3 Autoclosures
6 Enumerations, Structures und Classes
6.1 Enumerations
6.1.1 Enumerations und switch
6.1.2 Associated Values
6.1.3 Raw Values
6.2 Structures
6.2.1 Erstellen von Structures und Instanzen
6.2.2 Eigenschaften und Funktionen
6.2.2.1 Memberwise Initializer
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.4.2.1 Enumeration
6.4.2.2 Structure
6.4.2.3 Class
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.2.1 Einsatzzweck von Lazy Stored Properties
7.1.3 Computed Property
7.1.4 Read-Only Computed Property
7.1.5 Property Observer
7.1.6 Property Wrapper
7.1.6.1 Standardwerte festlegen
7.1.6.2 Weitere Parameter ergänzen
7.1.6.3 Projected Value
7.1.7 Type Property
7.2 Globale und lokale Variablen
7.3 Methoden
7.3.1 Instance Methods
7.3.1.1 mutating
7.3.2 Type Methods
7.4 Subscripts
8 Initialisierung
8.1 Aufgabe der Initialisierung
8.2 Erstellen eigener Initializer
8.3 Initializer Delegation
8.3.1 Initializer Delegation bei Value Types
8.3.2 Initializer Delegation bei Reference Types
8.4 Failable Initializer
8.5 Required Initializer
8.6 Deinitialisierung
9 Vererbung
9.1 Überschreiben von Eigenschaften und Funktionen einer Klasse
9.2 Überschreiben von Eigenschaften und Funktionen einer Klasse verhindern
9.3 Zugriff auf die Superklasse
9.4 Initialisierung und Vererbung
9.4.1 Zwei-Phasen-Initialisierung
9.4.2 Überschreiben von Initializern
9.4.3 Vererbung von Initializern
9.4.4 Required Initializer
10 Speicherverwaltung mit ARC
10.1 Strong Reference Cycles
10.1.1 Weak References
10.1.2 Unowned References
10.1.3 Weak Reference vs. Unowned Reference
11 Weiterführende Sprachmerkmale von Swift
11.1 Nested Types
11.2 Extensions
11.2.1 Computed Properties
11.2.2 Methoden
11.2.3 Initializer
11.2.4 Subscripts
11.2.5 Nested Types
11.3 Protokolle
11.3.1 Deklaration von Eigenschaften und Funktionen
11.3.1.1 Properties
11.3.1.2 Methoden
11.3.1.3 Subscripts
11.3.1.4 Initializer
11.3.2 Der Typ eines Protokolls
11.3.3 Protokolle und Extensions
11.3.3.1 Bestehenden Typ mittels Extension um Protokoll ergänzen
11.3.3.2 Protokoll mittels Extension um neue Funktionen und Standardimplementierung erweitern
11.3.4 Vererbung in Protokollen
11.3.5 Class-only-Protokolle
11.3.6 Optionale Eigenschaften und Funktionen
11.3.6.1 Umgang mit Protokoll-Type
11.3.7 Protocol Composition
11.3.8 Delegation
11.3.9 Übersicht diverser vorhandener Protokolle
11.3.9.1 Hashable
11.3.9.2 Identifiable
11.4 Key-Path
12 Type Checking und Type Casting
12.1 Type Checking mit „is“
12.2 Type Casting mit „as“
13 Error Handling
13.1 Deklaration und Feuern eines Fehlers
13.2 Reaktion auf einen Fehler
13.2.1 Mögliche Fehler mittels do-catch auswerten
13.2.2 Mögliche Fehler in Optionals umwandeln
13.2.3 Mögliche Fehler weitergeben
13.2.4 Mögliche Fehler ignorieren
14 Generics
14.1 Generic Functions
14.2 Generic Types
14.3 Type Constraints
14.4 Associated Types
15 Nebenläufigkeit
15.1 Asynchronen Code schreiben und aufrufen
15.2 Mehrere asynchrone Funktionen parallel ausführen
15.3 Priorität von Tasks festlegen
15.4 Ergebnisse über Task zurückliefern und auswerten
15.5 Actors
15.6 Main Actor
16 Dateien und Interfaces
16.1 Modules und Source Files
16.2 Access Control
16.2.1 Access Level
16.2.1.1 Private Access
16.2.1.2 File-private Access
16.2.1.3 Internal Access
16.2.1.4 Public Access
16.2.1.5 Open Access
16.2.1.6 Zusammenfassung und Übersicht
16.2.2 Explizite und implizite Zuweisung eines Access Levels
16.2.3 Besonderheiten
16.2.3.1 Variablen und Konstanten
16.2.3.2 Tuples
16.2.3.3 Type Aliase
16.2.3.4 Funktionen
16.2.3.5 Enumerations
16.2.3.6 Properties
16.2.3.7 Subscripts
16.2.3.8 Getter und Setter
16.2.3.9 Initializer
16.2.3.10 Vererbung
16.2.3.11 Extensions
16.2.3.12 Protokolle
Teil II: Xcode
17 Grundlagen, Aufbau und Einstellungen von Xcode
17.1 Über Xcode
17.2 Arbeiten mit Xcode
17.2.1 Dateien und Formate eines Xcode-Projekts
17.2.1.1 Projekte
17.2.1.2 Targets
17.2.1.3 Schemes
17.2.2 Umgang mit Dateien und Ordnern
17.2.2.1 Dateien in Xcode hinzufügen
17.2.2.2 Ordner in Xcode hinzufügen
17.2.2.3 Bereits vorhandene Dateien einem Xcode-Projekt hinzufügen
17.2.2.4 Dateien und Ordner löschen
17.3 Der Aufbau von Xcode
17.3.1 Toolbar
17.3.2 Navigator
17.3.3 Editor
17.3.4 Inspectors
17.3.5 Debug Area
17.4 Einstellungen
17.4.1 General
17.4.2 Accounts
17.4.3 Behaviors
17.4.4 Navigation
17.4.5 Themes
17.4.6 Text Editing
17.4.7 Key Bindings
17.4.8 Source Control
17.4.9 Components
17.4.10 Locations
17.5 Projekteinstellungen
17.5.1 Einstellungen am Projekt
17.5.2 Einstellungen am Target
17.5.2.1 General
17.5.2.2 Signing & Capabilities
17.5.2.3 Resource Tags
17.5.2.4 Info
17.5.2.5 Build Settings
17.5.2.6 Build Phases
17.5.2.7 Build Rules
17.5.3 Einstellungen am Scheme
17.5.3.1 Neues Scheme erstellen
17.5.3.2 Schemes verwalten
17.5.3.3 Ausführungsmöglichkeiten eines Schemes
18 Dokumentation, Devices und Organizer
18.1 Dokumentation
18.1.1 Aufbau und Funktionsweise
18.1.2 Direktzugriff im Editor
18.2 Devices und Simulatoren
18.2.1 Simulatoren
18.2.2 Devices
18.3 Organizer
19 Debugging und Refactoring
19.1 Debugging
19.1.1 Einfache Konsolenausgaben
19.1.2 Logging
19.1.3 Arbeiten mit Breakpoints
19.1.3.1 Breakpoints setzen und aktivieren
19.1.3.2 Variables View einsetzen
19.1.3.3 Ausführung der App fortsetzen
19.1.3.4 Breakpoints konfigurieren
19.1.3.5 Breakpoints vollständig deaktivieren
19.1.3.6 Breakpoint Navigator
19.1.4 Debug Navigator
19.2 Refactoring
19.3 Instruments
20 Tipps und Tricks für das effiziente Arbeiten mit Xcode
20.1 Code Snippets
20.2 Open Quickly
20.3 Related Items
20.4 Navigation über die Jump Bar
20.5 MARK, TODO und FIXME
20.6 Shortcuts für den Navigator
20.7 Clean Build
20.8 Playgrounds
20.8.1 Was sind Playgrounds?
20.8.2 Code schreiben und testen
20.8.3 Dateien hinzufügen
20.8.4 Kommentare und Dokumentation
20.8.5 Swift Playgrounds-App
Teil III: App-Entwicklung
21 Grundlagen der App-Entwicklung
21.1 Die Basis: SwiftUI
21.2 Bestandteile einer App
21.2.1 Umsetzung der Daten
21.2.2 Umsetzung der Ansichten
21.2.3 Weitere Frameworks
21.3 Die Syntax von SwiftUI
21.4 Aufbau einer App
21.5 Das View-Protokoll
21.6 Aktualisierung von Views mittels Status
21.7 Grundlagen des Status
21.8 Anpassung von Views mittels Modifier
21.9 Gruppierung von Views mittels Containern
21.10 Praxis: Unsere erste App
21.10.1 Bestandteile des neuen Projekts
21.10.2 Änderung des Textes
21.10.3 Einsatz der Preview
22 Views in SwiftUI
22.1 Textdarstellung und -bearbeitung
22.1.1 Text
22.1.1.1 Anpassung der Schriftart
22.1.1.2 Formatierung von Texten
22.1.1.3 Übersetzung von Texten
22.1.1.4 Umgang mit Datumsangaben
22.1.2 TextField
22.1.3 SecureField
22.1.4 TextEditor
22.1.4.1 Formatierung des Textes
22.2 Bilder
22.2.1 Image-Instanz erstellen
22.2.2 Größe einer Image-Instanz ändern
22.3 Schaltflächen
22.3.1 Button
22.3.2 EditButton
22.3.3 PasteButton
22.4 Werteauswahl
22.4.1 Toggle
22.4.2 Slider
22.4.3 Stepper
22.4.4 Picker
22.4.5 DatePicker
22.4.6 MultiDatePicker
22.4.7 ColorPicker
22.5 Weitere Views
22.5.1 Label
22.5.2 ProgressView
22.5.3 Gauge
23 View-Layout
23.1 Stacks
23.1.1 HStack
23.1.2 VStack
23.1.3 ZStack
23.1.4 Stacks verschachteln
23.1.5 Lazy Stacks
23.2 Listen
23.2.1 List
23.2.2 ForEach
23.3 Grids
23.3.1 Grid
23.3.2 LazyHGrid und LazyVGrid
23.4 Table
23.4.1 Zellen selektieren
23.4.2 Sortierung ändern
23.5 Container-Views
23.5.1 Form
23.5.2 Section
23.5.3 Group
23.5.4 GroupBox
23.5.5 ViewThatFits
23.6 Weitere Views
23.6.1 ScrollView
23.6.2 OutlineGroup
23.6.3 DisclosureGroup
23.6.4 Spacer
23.6.5 Divider
24 Navigation
24.1 NavigationStack und NavigationLink
24.1.1 Titel in Navigation-Bar setzen
24.1.2 Eigene View zur Darstellung eines NavigationLink nutzen
24.1.3 Anzeige einer Ziel-View auf Basis von Daten
24.1.4 Programmatische Steuerung des Navigation-Stacks
24.2 NavigationSplitView
24.2.1 Verknüpfung von NavigationSplitView und List
24.2.2 Sichtbarkeit der Spalten steuern
24.2.3 Breite der Spalten anpassen
24.2.4 Verhalten von NavigationSplitView unter den verschiedenen Apple-Plattformen
24.3 TabView
24.4 HSplitView und VSplitView
24.5 Funktionen zur Präsentation von Views
24.5.1 Sheet einblenden
24.5.2 View über gesamtes Fenster legen
24.5.3 Popover einblenden
25 Weitere View-Konfigurationen
25.1 Toolbar
25.2 Alerts
25.3 Confirmation Dialog
25.4 Farben
25.5 View-Events
25.6 Eigene Modifier umsetzen und aufrufen
26 Status
26.1 Property
26.2 State
26.3 Binding
26.4 ObservedObject
26.4.1 Datenmodell vorbereiten
26.4.2 Datenmodell in View einbinden
26.4.3 Auf Änderungen reagieren
26.5 StateObject
26.6 EnvironmentObject
26.7 @Observable-Makro und Bindable
26.8 Environment
26.9 SceneStorage
26.10 AppStorage
26.11 Source of Truth vs. Derived Value
26.12 Best Practices
27 Datenhaltung
27.1 UserDefaults
27.1.1 UserDefaults und SwiftUI
27.2 SwiftData
27.2.1 Grundlegende Funktionsweise von SwiftData
27.2.2 Erstellen des eigenen Datenmodells
27.2.3 Model-Container erzeugen
27.2.4 Elemente im ModelContext verwalten
27.2.5 Zusammenspiel mit der Preview
27.3 Core Data
27.3.1 Grundlegende Funktionsweise von Core Data
27.3.2 Grundlegende Elemente beim Einsatz von Core Data
27.3.2.1 NSPersistentStore
27.3.2.2 NSManagedObjectModel
27.3.2.3 NSManagedObject
27.3.2.4 NSManagedObjectContext
27.3.2.5 NSPersistentStoreCoordinator
27.3.2.6 NSPersistentContainer
27.3.3 Einen Core Data Stack erstellen
27.3.4 Ein Managed Object Model erstellen
27.3.4.1 Entitäten und Eigenschaften erstellen
27.3.4.2 Relationships zwischen Entitäten
27.3.4.3 Entitäten und Attribute als Managed Objects
27.3.5 Grundlegende Core-Data-Operationen
27.3.5.1 Managed Object erstellen und konfigurieren
27.3.5.2 Gespeicherte Managed Objects laden
27.3.5.3 Bestehende Managed Objects löschen
27.3.6 Core Data mit SwiftUI
27.3.6.1 NSManagedObject als Status
27.3.6.2 Zugriff auf Managed Object Context
27.3.6.3 Auslesen persistent gespeicherter Elemente
28 Weitere Projektkonfigurationen
28.1 Cross-Platform-Entwicklung
28.1.1 Neue Targets hinzufügen
28.1.2 Target-Zuweisung
28.1.3 Plattform im Code prüfen
28.1.4 Funktionen auf Verfügbarkeit prüfen
28.2 Mehrsprachigkeit
28.2.1 Grundlagen
28.2.1.1 Erstellen eines String Catalogs
28.2.1.2 Übersetzungen im Code kennzeichnen
28.2.1.3 Auf Übersetzungen im Code zugreifen
28.2.1.4 Übersetzungen mit dynamischem Parameter konfigurieren
28.2.2 Verschiedene Sprachen einer App testen
28.3 Asset Catalogs
29 Preview und Library
29.1 Preview
29.1.1 Funktionsweise der Preview
29.1.2 Konfiguration der Preview
29.1.3 Preview ausführen und anhalten
29.2 Library
29.3 Attributes Inspector
Teil IV: Source Control und Testing
30 Source Control
30.1 Basisfunktionen und -begriffe der Source Control
30.2 Source Control in Xcode
30.2.1 Bestehendes Projekt klonen
30.2.2 Lokale Änderungen committen
30.2.3 Lokale Änderungen verwerfen
30.2.4 Pull und Push
30.2.5 Aktuelle Branches vom Repository laden
30.2.6 Git-Repository mit neuem Xcode-Projekt erzeugen
30.2.7 Optische Source-Control-Hervorhebungen im Editor
30.2.8 Zugriff auf GitHub, GitLab und Bitbucket
30.3 Source Control Navigator
30.4 Code Review-Mode
31 Testing
31.1 Unit-Tests
31.1.1 Unit-Tests mit Swift Testing
31.1.2 Unit-Tests mit XCTest
31.1.3 Neue Test-Datei erstellen
31.1.4 Ausführen von Unit-Tests
31.2 Performancetests
31.3 UI-Tests
31.3.1 Klassen für UI-Tests
31.3.2 Aufbau von UI-Test-Klassen
31.3.3 Automatisches Erstellen von UI-Tests
31.3.4 Einsatz von UI-Tests
Teil V: Veröffentlichung von Apps
32 Veröffentlichung im App Store
32.1 Das Apple Developer Portal
32.1.1 Zertifikate, App IDs und Provisioning Profiles
32.1.1.1 Erstellen von Entwicklerzertifikaten
32.1.1.2 Erstellen von App IDs
32.1.1.3 Hinzufügen von Devices
32.1.1.4 Erstellen von Provisioning Profiles
32.1.2 Code Signing
32.1.2.1 Automatic Code Signing
32.1.2.2 Manual Code Signing
32.1.2.3 Code Signing in den Build Settings
32.2 App Store Connect
32.2.1 Apps für den App Store vorbereiten und verwalten
32.2.2 Apps erstellen, hochladen und einreichen
32.3 App Store Review Guidelines
33 Das Business Model für Ihre App
33.1 Geschäftsmodelle
33.1.1 Free Model
33.1.2 Freemium Model
33.1.3 Subscription Model
33.1.4 Paid Model
33.1.5 Paymium Model
33.2 App Bundles
33.3 Veröffentlichung außerhalb des App Store
33.3.1 Das Apple Developer Enterprise Program
34 TestFlight
34.1 TestFlight in App Store Connect
34.2 TestFlight im App Store
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 2024 erschienenen Version 6 von Swift sowie der Version 16 der Entwicklungsumgebung Xcode. Alle Kapitel der vorherigen Auflage wurden entsprechend aktualisiert sowie um neue Inhalte ergänzt. Zu den Highlights dieser Neuerungen zählt unter anderem das Swift Testing-Framework zum Schreiben und Ausführen von Unit-Tests, aktualisierte Navigationsmöglichkeiten sowie Optimierungen beim Debugging.
Generell schlägt diese vierte Auflage des SwiftHandbuchs 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 macOS, iOS/iPadOS, watchOS und tvOS:
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 vorne auf der ersten Seite des Buches 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
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
Oktober 2024
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: Vererbung
Kapitel 10: Speicherverwaltung mit ARC
Kapitel 11: Weiterführende Sprachmerkmale von Swift
Kapitel 12: Type Checking und Type Casting
Kapitel 13: Error-Handling
Kapitel 14: Generics
Kapitel 15: Nebenläufigkeit
Kapitel 16: Dateien und Interfaces
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 SwiftKeine 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 SwiftCommunity, 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-KosmosAus 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: SwiftUIIn 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 brauchenUm 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): PlaygroundsWenn 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 SwiftPlaygrounds-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 SwiftPlaygrounds-App tun. Wenn Sie aber erst einmal näher mit der SwiftProgrammierung 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.
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-AppFür macOS, iOS und tvOS 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-WebsiteEine 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.
Wenn Sie sich im Speziellen für die Programmiersprache Swift interessieren, ist die offizielle Website 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.
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.
