iOS 14 Programming Fundamentals with Swift: Swift, Xcode, and Cocoa Basics

Cover
Copyright
Table of Contents
Preface
	The Scope of This Book
	From the Preface to the First Edition (Programming iOS 4)
	Versions
	Acknowledgments
	Conventions Used in This Book
	Using Code Examples
	O’Reilly Online Learning
	How to Contact Us
Part I. Language
	Chapter 1. The Architecture of Swift
		Ground of Being
		Everything Is an Object?
		Three Flavors of Object Type
		Variables
		Functions
		The Structure of a Swift File
		Scope and Lifetime
		Object Members
		Namespaces
		Modules
		Instances
		Why Instances?
		The Keyword self
		Privacy
		Design
	Chapter 2. Functions
		Function Parameters and Return Value
			Void Return Type and Parameters
			Function Signature
		External Parameter Names
		Overloading
		Default Parameter Values
		Variadic Parameters
		Ignored Parameters
		Modifiable Parameters
			Calling Objective-C with Modifiable Parameters
			Called by Objective-C with Modifiable Parameters
			Reference Type Modifiable Parameters
		Function in Function
		Recursion
		Function as Value
		Anonymous Functions
			Using Anonymous Functions Inline
			Anonymous Function Abbreviated Syntax
		Define-and-Call
		Closures
			How Closures Improve Code
			Function Returning Function
			Closure Setting a Captured Variable
			Closure Preserving Captured Environment
			Escaping Closures
		Curried Functions
		Function References and Selectors
			Function Reference Scope
			Selectors
	Chapter 3. Variables and Simple Types
		Variable Scope and Lifetime
		Variable Declaration
		Computed Variable Initialization
		Computed Variables
			Computed Properties
			Property Wrappers
		Setter Observers
		Lazy Initialization
			Singleton
			Lazy Initialization of Instance Properties
		Built-In Simple Types
			Bool
			Numbers
			String
			Character and String Index
			Range
			Tuple
			Optional
	Chapter 4. Object Types
		Object Type Declarations and Features
			Initializers
			Properties
			Methods
			Subscripts
			Nested Object Types
		Enums
			Raw Values
			Associated Values
			Enum Case Iteration
			Enum Initializers
			Enum Properties
			Enum Methods
			Why Enums?
		Structs
			Struct Initializers
			Struct Properties
			Struct Methods
			Struct as Namespace
		Classes
			Value Types and Reference Types
			Subclass and Superclass
			Class Initializers
			Class Deinitializer
			Class Properties
			Static/Class Members
		Polymorphism
		Casting
			Casting Down
			Type Testing and Casting Down Safely
			Type Testing and Casting Optionals
			Bridging to Objective-C
		Type References
			From Instance to Type
			From self to Type
			Type as Value
			Summary of Type Terminology
			Comparing Types
		Protocols
			Why Protocols?
			Adopting a Library Protocol
			Protocol Type Testing and Casting
			Declaring a Protocol
			Protocol Composition
			Class Protocols
			Optional Protocol Members
			Implicitly Required Initializers
			Expressible by Literal
		Generics
			Generic Declarations
			Contradictory Resolution Is Impossible
			Type Constraints
			Explicit Specialization
			Generic Invariance
			Associated Type Chains
			Where Clauses
		Extensions
			Extending Protocols
			Extending Generics
		Umbrella Types
			Any
			AnyObject
			AnyClass
		Collection Types
			Array
			Dictionary
			Set
	Chapter 5. Flow Control and More
		Flow Control
			Branching
			Loops
			Jumping
		Privacy
			Private and Fileprivate
			Public and Open
			Privacy Rules
		Introspection
		Operators
		Memory Management
			Memory Management of Reference Types
			Exclusive Access to Value Types
		Miscellaneous Swift Language Features
			Synthesized Protocol Implementations
			Key Paths
			Instance as Function
			Dynamic Membership
			Property Wrappers
			Custom String Interpolation
			Reverse Generics
			Function Builders
			Result
Part II. IDE
	Chapter 6. Anatomy of an Xcode Project
		New Project
		The Project Window
			The Navigator Pane
			The Inspectors Pane
			The Editor
		Project File and Dependents
			Contents of the Project Folder
			Groups
		The Target
			Build Phases
			Build Settings
			Configurations
			Schemes and Destinations
		From Project to Built App
			Build Settings
			Property List Settings
			Nib Files
			Resources
			Code Files
			Frameworks, SDKs, and Packages
		The App Launch Process
			The Entry Point
			How an App Gets Going
			App Without a Storyboard
		Renaming Parts of a Project
	Chapter 7. Nib Files
		The Nib Editor Interface
			Document Outline
			Canvas
			Inspectors
		Loading a Nib
			Loading a View Controller Nib
			Loading a Main View Nib
			Loading a View Nib Manually
		Connections
			Outlets
			The Nib Owner
			Automatically Configured Nibs
			Misconfigured Outlets
			Deleting an Outlet
			More Ways to Create Outlets
			Outlet Collections
			Action Connections
			More Ways to Create Actions
			Misconfigured Actions
			Connections Between Nibs — Not!
		Additional Configuration of Nib-Based Instances
	Chapter 8. Documentation
		The Documentation Window
		Class Documentation Pages
		Quick Help
		Symbol Declarations
		Header Files
		Sample Code
		Internet Resources
	Chapter 9. Life Cycle of a Project
		Environmental Dependencies
			Conditional Compilation
			Build Action
			Permissible Runtime Environment
			Backward Compatibility
			Device Type
			Arguments and Environment Variables
		Version Control
		Editing and Navigating Your Code
			Text Editing Preferences
			Multiple Selection
			Autocompletion and Placeholders
			Snippets
			Refactoring and Structure Editing
			Fix-it and Live Syntax Checking
			Navigation
			Finding
		Running in the Simulator
		Debugging
			Caveman Debugging
			The Xcode Debugger
		Testing
			Unit Tests
			Interface Tests
			Test Plans
			Massaging the Report
		Clean
		Running on a Device
			Obtaining a Developer Program Membership
			Signing an App
			Automatic Signing
			Manual Signing
			Running the App
			Managing Development Certificates and Devices
		Profiling
			Gauges
			Memory Debugging
			Instruments
		Localization
			Creating Localized Content
			Testing Localization
		Distribution
			Making an Archive
			The Distribution Certificate
			The Distribution Profile
			Distribution for Testing
			Final App Preparations
			Screenshots and Video Previews
			Property List Settings
			Submission to the App Store
Part III. Cocoa
	Chapter 10. Cocoa Classes
		Subclassing
		Categories and Extensions
			How Swift Uses Extensions
			How You Use Extensions
			How Cocoa Uses Categories
		Protocols
			Optional Members
			Informal Protocols
		Some Foundation Classes
			NSRange
			NSNotFound
			NSString and Friends
			NSDate and Friends
			NSNumber
			NSValue
			NSData
			NSMeasurement and Friends
			Equality, Hashability, and Comparison
			NSArray and NSMutableArray
			NSDictionary and NSMutableDictionary
			NSSet and Friends
			NSIndexSet
			NSNull
			Immutable and Mutable
			Property Lists
			Codable
		Accessors, Properties, and Key–Value Coding
			Swift Accessors
			Key–Value Coding
			How Outlets Work
			Cocoa Key Paths
			Uses of Key–Value Coding
			KeyPath Notation
		The Secret Life of NSObject
	Chapter 11. Cocoa Events
		Reasons for Events
		Subclassing
		Notifications
			Receiving a Notification
			Unregistering
			Posting a Notification
			Timer
		Delegation
			Cocoa Delegation
			Implementing Delegation
		Data Sources
		Actions
			The Responder Chain
			Nil-Targeted Actions
		Key–Value Observing
			Registration and Notification
			Unregistering
			Key–Value Observing Example
		Swamped by Events
		Delayed Performance
	Chapter 12. Memory Management
		Principles of Cocoa Memory Management
		Rules of Cocoa Memory Management
		What ARC Is and What It Does
		How Cocoa Objects Manage Memory
		Autorelease Pool
		Memory Management of Instance Properties
		Retain Cycles and Weak References
		Unusual Memory Management Situations
			Notification Observers
			KVO Observers
			Timers
			Other Unusual Situations
		Nib Loading and Memory Management
		Memory Management of CFTypeRefs
		Property Memory Management Policies
		Debugging Memory Management Mistakes
	Chapter 13. Communication Between Objects
		Visibility Through an Instance Property
		Visibility by Instantiation
		Getting a Reference
			Visibility by Relationship
			Global Visibility
		Notifications and Key–Value Observing
		The Combine Framework
		Alternative Architectures
			Model–View–Controller
			Router and Data Space
			Model–View–Presenter
			Protocols and Reactive Programming
			VIPER
		SwiftUI
			Function Builders and Modifiers
			State Properties
			Bindings
			Passing Data Downhill
			Passing Data Uphill
			Custom State Objects
	Appendix A. C, Objective-C, and Swift
		The C Language
			C Data Types
			C Enums
			C Structs
			C Pointers
			C Arrays
			C Strings
			C Functions
		Objective-C
			Objective-C Objects and C Pointers
			Objective-C Objects and Swift Objects
			Exposure of Swift to Objective-C
			Bridged Types and Boxed Types
			Objective-C Methods
			Selectors
			CFTypeRefs
			Blocks
			API Markup
		Bilingual Targets
Index
About the Author