Sams Teach Yourself Swift In 24 Hours 1st Edition

Swift builds on the best of C and Objective-C, without their constraints, and integrates 20 years of advances in Apple development. Now, in just 24 lessons of one hour or less, you can learn all the Swift development skills you'll need, even if you're new to Apple programming. Each short, easy lesson builds on all that's come before: you'll learn all of Swift's essentials as you build complete iOS apps with the newest version of Cocoa Touch framework. Sams Teach Yourself Swift in 24 Hours covers all this, and much more:

• Getting started with Swift in the Xcode 6 development environment
• Mastering Swift's basic data types, arrays, and dictionaries
• Controlling program flow
• Mastering functions, closures, classes, structs, and Enums
• Adding properties and methods
• Implementing Protocols and Extensions
• Writing your first iOS app with Cocoa Touch
• Using buttons, sliders, steppers, and other interface elements
• Working with Table Views, View Navigation, and MVC
• Implementing Unified Storyboards for Universal Apps
• Accessing device location information
• Creating and using app extensions
• Using Touch ID authentication
• Working with the Photos Framework and camera controls
• Getting started with Apple's new Health Kit and Home Kit frameworks
• Using the HandOff API to create seamless handoffs between devices
• Syncing with Cloud Kit
• Debugging Swift apps with Xcode 6

Step-by-step instructions walk you through common questions, issues, and tasks; Q-and-As, Quizzes, and Exercises build and test your knowledge; "Did You Know?" tips offer insider advice and shortcuts; and "Watch Out!" alerts help you avoid problems. By the time you're finished, you'll be comfortable going beyond the book to create any Swift app you can imagine!

This book’s straightforward, step-by-step approach helps you quickly master Swift’s core concepts, structure, and syntax and use Swift to write safe, powerful, modern code. In just a few hours you’ll be applying advanced features such as extensions, closures, protocols, and generics. Every lesson builds on what you’ve already learned, giving you a rock-solid foundation for real-world success.

Step-by-step instructions carefully walk you through the most common Swift development tasks.

Practical, hands-on examples show you how to apply what you learn.

Quizzes and exercises help you test your knowledge and stretch your skills.

Notes and tips point out shortcuts and solutions.

Learn how to...

• Set up your Swift development environment
• Master Swift’s fundamental data types and operators
• Make the most of arrays and dictionaries
• Control program flow, modify execution paths, and iterate code
• Perform complex actions with functions
• Work with higher-order functions and closures
• Harness the power of structs, enums, classes, and class inheritance
• Customize initializers of classes, structs, and enums
• Implement instance methods, type methods, and advanced type functionality
• Take full advantage of Swift’s advanced memory allocation
• Extend type functionality with protocols and extensions
• Leverage the power of generics, chaining, and other advanced features
• Interoperate with Objective-C code
• Interact with user interfaces
• Take advantage of Swift’s Standard Library features and functions

BJ began iOS development in 2009 after not having programmed for a few years, and he developed a passion for the platform and the Objective-C language. Now, his love has expanded to include Swift, and there is still yet room in his heart for more. In 2013 he released his first app into the iOS App Store, called MyPrayerMap, as a simple tool for managing prayer requests.

When he is not writing in Objective-C or Swift for either work or this book, he enjoys spending time with his wife and two boys, reading, listening to music or podcasts, and playing The Legend of Zelda (any game on any system will do). He also co-organizes the Cleveland CocoaHeads Meetup with Daniel Steinberg, http://www.meetup.com/Cleveland-CocoaHeads/, and organizes a submeetup of that group called Paired Programming Fun, which is a casual meetup where the focus is on Test-Driven Development (TDD) in Swift and Objective-C in paired-programming style. BJ often presents iOS-related topics at CocoaHeads and also speaks at other conferences such as CocoaConf (Columbus, Ohio) and CodeMash v2.0.1.5. He also blogs from time to time at http://bjmiller.me and is on Twitter as @bjmillerltd.

HOUR 1: Introducing the Swift Development Environment     1

What Is Swift?      2

Getting Started     2

Summary     9

Q&A     10

Workshop     10

Exercise     11

HOUR 2: Learning Swift’s Fundamental Data Types     13

Constants in Swift     13

Variables in Swift      14

Introducing Data Types     15

Summary     23

Q&A     24

Workshop     24

Exercise     25

HOUR 3: Using Operators in Swift     27

Unary Operators     27

Binary Operators     29

Ternary Conditional Operators     35

Summary     35

Q&A     36

Workshop     36

Exercise     37

HOUR 4: Working with Collection Types     39

Arrays     39

Dictionaries     46

Tuples     50

Summary     51

Q&A     51

Workshop     52

Exercise     52

HOUR 5: Understanding Optional Values     53

What Are Optional Values?      53

How to Designate a Variable as Optional      54

Wrapping and Unwrapping Optional Variables     54

Use Case for Optionals     58

Summary     61

Q&A     62

Workshop     62

Exercise     63

HOUR 6: Controlling Program Flow with Conditionals     65

The if Statement      65

The switch Statement      70

Summary     77

Q&A     78

Workshop     78

Exercise     80

HOUR 7: Iterating Code with Loops     81

Two Categories of Loops     81

Transferring Control in Loops     93

Summary     95

Q&A     95

Workshop     96

Exercise     97

HOUR 8: Using Functions to Perform Actions     99

The Nature of Functions in Swift     100

General Function Syntax and Structure     100

Functions with No Parameters and No Return Type     102

The Type of a Function     102

Functions with Parameters     103

Functions with Variadic Parameters     105

Functions with Return Types     106

External Parameter Names     111

Default Parameter Values     112

Change Argument Values with In-Out Parameters     112

Summary     113

Q&A     114

Workshop     114

Exercise     115

HOUR 9: Understanding Higher Order Functions and Closures     117

Higher Order Functions     117

Closures     124

Summary     132

Q&A     133

Workshop     133

Exercise     135

HOUR 10: Learning About Structs and Classes     137

Overview of Structs and Classes in Swift     137

What Swift Structs and Classes Have in Common     139

Differences Between Structs and Classes     147

When to Use a Class or a Struct     150

Summary     151

Q&A     151

Workshop     152

Exercise     153

HOUR 11: Implementing Class Inheritance     155

What Is Inheritance?      155

Identifying a Base Class     156

Creating a Subclass     157

Overriding Inherited Methods     159

Accessing super     162

Preventing Overrides     164

Class Identity     166

Summary     167

Q&A     168

Workshop     169

Exercise     170

HOUR 12: Harnessing the Power of Enums     171

Understanding Swift Enums     171

Swift Enum Structure     172

Raw Values     173

Enum Shorthand Syntax     175

Associated Values     177

Switching Enum Values     178

Adding Instance Methods to Enums     180

Summary     182

Q&A     183

Workshop     183

Exercise     184

HOUR 13: Customizing Initializers of Classes, Structs, and Enums     185

Initialization     185

Initializing Value Types     187

Advanced Initialization     193

Summary     201

Q&A      202

Workshop     202

Exercise     203

HOUR 14: Digging Deeper with Properties     205

Stored Properties     206

Computed Properties     209

Property Accessors     209

Property Observers     212

Inheriting and Overriding Accessors     215

Inheriting and Overriding Observers     217

Summary     221

Q&A     221

Workshop     222

Exercise     222

HOUR 15: Adding Advanced Type Functionality     223

Type Properties and Methods     223

Type Aliasing     229

Type Access Control     230

Subscripts     231

Type Casting and Non-Specific Types     235

Summary     239

Q&A     239

Workshop     240

Exercise     241

HOUR 16: Understanding Memory Allocation and References     243

Deinitialization     243

Automatic Reference Counting     247

Summary     259

Q&A     260

Workshop     261

Exercise     261

HOUR 17: Using Protocols to Define Behavior     263

Defining Protocols     263

Creating and Adopting Protocols     264

Properties     265

Defining Methods in Protocols     266

Using Protocol Names as Types     268

Adopting and Inheriting Multiple Protocols     269

Optional Protocol Properties and Methods     273

How to Check for Protocol Conformance     275

Using Protocols for Delegation     275

Summary     280

Q&A     281

Workshop     282

Exercise     282

HOUR 18: Using Extensions to Add Type Functionality     285

Defining Extensions     285

Adding Functionality with Extensions     287

Summary     297

Q&A     297

Workshop     298

Exercise     298

HOUR 19: Working with Optional Chaining     301

Defining Optional Chaining     301

Chaining Optional Properties     302

Subscripts     303

Methods     308

Summary     310

Q&A     311

Workshop     311

Exercise     312

HOUR 20: Introducing Generics     313

An Introduction to Generics     313

Type Parameters and Placeholder Types     314

Specifying Type Constraints     315

Creating Generic Types     319

Extending Generic Types     322

Using Associated Types in Protocols     323

Summary     325

Q&A     326

Workshop     326

Exercise     327

HOUR 21: Adding Interoperability with Objective-C     329

Objective-C Basics     329

Bridging     335

Integrating Swift into an Objective-C App     337

Summary     346

Q&A     347

Workshop     348

Exercise     348

HOUR 22: Interacting with User Interfaces     351

Interface Introduction     351

Interface Definitions     352

Building an Interface     353

Creating Your Own Project     355

Adding UI Elements     355

Summary     369

Q&A     370

Workshop     370

Exercise     371

HOUR 23: Asynchronous Programming in Swift     373

The Problem That Concurrency Solves     373

Different Types of Queues     374

Asynchronous Programming in Action     376

Add iTunes Search to Songs App     380

Parsing JSON     383

Summary     390

Q&A     390

Workshop     391

Exercise     392

HOUR 24: Learning Swift’s Standard Library Functions     393

What Is a Standard Library?      393

Numeric Types     394

String Type     394

Protocols     395

Functional Functions     399

Global Functions     401

Summary     404

Q&A     405

Workshop     405

Exercise     406

Index     409