Librería Portfolio

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



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