Swift in 24 Hours, Sams Teach Yourself (B&N Special Edition) / Edition 2

by BJ Miller

Overview

In just 24 lessons of one hour or less, Sams Teach Yourself Swift in 24 Hours, Second Edition, will teach you how to build next-generation OS X and iOS apps with Apple’s Swift 2 programming language. This book’s straightforward, step-by-step approach helps you quickly master Swift 2’s core concepts, structure, and syntax and use Swift to write safe, powerful, modern code. In just a few hours you’ll be applying 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 2 programming 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...

• Get started with Swift 2.0’s Xcode 7 development environment
• Master Swift’s fundamental data types
• Use operators to change, assign, combine, check, or verify values
• Retain data and preferences in memory with arrays, sets, and dictionaries
• Control program flow, modify execution paths, and iterate code
• Perform complex actions concisely with Swift 2.0’s improved functions
• Work with higher-order functions and closures
• Harness the power of structs, enums, classes, and class inheritance
• Take advantage of Swift’s advanced memory allocation and references
• Use protocols to define behavior and explore Protocol-Oriented Programming
• Add type functionality with extensions
• Smoothly handle errors
• Leverage the power of generics to create flexible and reusable code
• Interoperate with Objective-C code
• Get started with Functional Programming approaches and thinking functionally

This custom Barnes & Noble edition of the book offers free access to the Learning Lab for the book. The Learning Labs is an enhanced ebook that offers 3 to 5 video tutorials per chapter, as well as end-of-chapter quizzes.

Product Details

ISBN-13:	9780672337680
Publisher:	Sams
Publication date:	12/06/2015
Series:	Sams Teach Yourself Series
Sales rank:	439,122
Product dimensions:	7.00(w) x 9.10(h) x 1.00(d)

About the Author

BJ Miller is an iOS developer for DXY Solutions, a mobile, web, and design consultancy in the Cleveland, Ohio, area. BJ earned his B.S. in Computer Science from Baldwin-Wallace College (now called Baldwin-Wallace University) in Berea, Ohio, the town where he grew up. His latest career path encompassed large-scale enterprise network administration, SQL database administration, and Microsoft SharePoint Server and Microsoft Project Server administration and integration as a contractor for the United States Department of Defense, with all the Microsoft certifications that come along with that. Before that, he spent several years in LAN engineering, designing and implementing network infrastructure, as a Cisco Certified Network Associate.

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 in paired-programming style. BJ often presents iOS-related topics at CocoaHeads and also speaks at other conferences such as MacTech, 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.

Table of Contents

Introduction xiv
Who Should Read This Book? xv
What Should You Expect from This Book? xvi
HOUR 1: Introducing the Swift Development Environment 1
What Is Swift? 1
Getting Started 2
Summary 10
Q&A 11
Workshop 11
Exercise 12
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 36
Q&A 36
Workshop 37
Exercise 37
HOUR 4: Working with Collection Types 39
Arrays 39
Dictionaries 47
Sets 51
Tuples 55
Summary 56
Q&A 56
Workshop 57
Exercise 57
HOUR 5: Controlling Program Flow with Conditionals 59
The if Statement 59
The switch Statement 64
Summary 73
Q&A 74
Workshop 74
Exercise 75
HOUR 6: Understanding Optional Values 77
What Are Optional Values? 77
How to Designate a Variable as Optional 78
Wrapping and Unwrapping Optional Variables 79
Use Case for Optionals 85
Summary 87
Q&A 87
Workshop 87
Exercise 88
HOUR 7: Iterating Code with Loops 89
Two Categories of Loops 89
Transferring Control in Loops 102
Summary 104
Q&A 104
Workshop 104
Exercise 106
HOUR 8: Using Functions to Perform Actions 107
The Nature of Functions in Swift 108
General Function Syntax and Structure 108
Functions with No Parameters and No Return Type 110
The Type of a Function 110
Functions with Parameters 111
Functions with Variadic Parameters 113
Functions with Return Types 114
External Parameter Names 118
Default Parameter Values 120
Change Argument Values with In-Out Parameters 120
Exiting Early 121
Deferring Execution 122
Summary 123
Q&A 124
Workshop 124
Exercise 125
HOUR 9: Understanding Higher Order Functions and Closures 127
Higher Order Functions 127
Closures 134
Summary 143
Q&A 144
Workshop 144
Exercise 145
HOUR 10: Learning About Structs and Classes 147
Overview of Structs and Classes in Swift 147
What Swift Structs and Classes Have in Common 149
Differences Between Structs and Classes 157
When to Use a Class or a Struct 160
Summary 161
Q&A 161
Workshop 162
Exercise 163
HOUR 11: Implementing Class Inheritance 165
What Is Inheritance? 165
Identifying a Base Class 166
Creating a Subclass 167
Overriding Inherited Methods 169
Accessing super 172
Preventing Overrides 174
Class Identity 176
When to Use Class Inheritance 177
Summary 178
Q&A 179
Workshop 179
Exercise 181
HOUR 12: Harnessing the Power of Enums 183
Understanding Swift Enums 183
Swift Enum Structure 184
Raw Values 185
Enum Shorthand Syntax 187
Associated Values 189
Switching Enum Values 190
Adding Instance Methods to Enums 192
Summary 195
Q&A 195
Workshop 196
Exercise 197
HOUR 13: Customizing Initializers of Classes, Structs, and Enums 199
Initialization 199
Initializing Value Types 201
Advanced Initialization 209
Summary 217
Q&A 218
Workshop 218
Exercise 219
HOUR 14: Digging Deeper with Properties 221
Stored Properties 221
Computed Properties 224
Property Accessors 225
Property Observers 228
Inheriting and Overriding Accessors 231
Inheriting and Overriding Observers 233
Summary 236
Q&A 236
Workshop 237
Exercise 237
HOUR 15: Adding Advanced Type Functionality 239
Type Properties and Methods 239
Type Aliasing 246
Type Access Control 247
Subscripts 249
Type Casting and Non-Specific Types 253
Summary 257
Q&A 258
Workshop 258
Exercise 259
HOUR 16: Understanding Memory Allocation and References 261
Deinitialization 261
Automatic Reference Counting 265
Summary 275
Q&A 276
Workshop 277
Exercise 277
HOUR 17: Using Protocols to Define Behavior 279
Defining Protocols 279
Creating and Adopting Protocols 280
Properties 281
Defining Methods in Protocols 282
Using Protocol Names as Types 284
Adopting and Inheriting Multiple Protocols 285
Optional Protocol Properties and Methods 290
How to Check for Protocol Conformance 291
Using Protocols for Delegation 292
Summary 297
Q&A 298
Workshop 298
Exercise 299
HOUR 18: Using Extensions to Add Type Functionality 301
Defining Extensions 301
Adding Functionality with Extensions 303
Summary 313
Q&A 313
Workshop 313
Exercise 314
HOUR 19: Working with Optional Chaining 315
Defining Optional Chaining 315
Chaining Optional Properties 316
Subscripts 318
Methods 322
Summary 324
Q&A 325
Workshop 325
Exercise 326
HOUR 20: Introducing Generics 327
An Introduction to Generics 327
Type Parameters and Placeholder Types 328
Specifying Type Constraints 329
Creating Generic Types 333
Extending Generic Types 336
Using Associated Types in Protocols 337
Summary 339
Q&A 340
Workshop 340
Exercise 341
HOUR 21: Understanding Protocol-Oriented Programming 343
A Quick Recap of Protocols 343
Implementing Protocols 344
Introducing Protocol Extensions 344
Creating Protocol Extensions 346
What Is and Isn’t Customizable 349
Type Constraints in Protocol Extensions 352
Homogeneous and Heterogeneous Collections 353
Converting Protocol Sequences 355
Summary 357
Q&A 357
Workshop 358
Exercise 359
HOUR 22: Handling Errors 361
Error Handling 361
Swift Error Handling 363
Summary 374
Q&A 375
Workshop 376
Exercise 376
HOUR 23: Adding Interoperability with Objective-C 377
Objective-C Basics 377
Bridging 384
Integrating Swift into an Objective-C App 387
Summary 399
Q&A 399
Workshop 400
Exercise 400
HOUR 24: Functional Thinking in Swift 403
What Is Functional Programming? 403
Thinking in Terms of Functions 404
Summary 418
Q&A 419
Workshop 419
Exercise 420
Index 421