The Swift Developer's Cookbook (includes Content Update Program) - Erica Sadun

The Swift Developer's Cookbook (includes Content Update Program)

(Autor)

Buch | Softcover
240 Seiten
2015
Addison-Wesley Educational Publishers Inc (Verlag)
978-0-13-439526-5 (ISBN)
39,95 inkl. MwSt
  • Titel ist leider vergriffen;
    keine Neuauflage
  • Artikel merken
In The Swift Developer’s Cookbook, renowned author Erica Sadun joins powerful strategies with ready-to-use Swift code for solving everyday development challenges.

As in all of Sadun’s programming best-sellers, The Swift Developer’s Cookbook translates modern best practices into dozens of well-tested, easy-to-apply solutions. This book’s code examples were created in response to real-world questions from working developers to reflect Swift’s newest capabilities and best practices. Each chapter groups related tasks together. You can jump straight to your solution without having to identify the right class or framework first.

Sadun covers key Swift development concepts, shows you how to write robust and efficient code, and helps you avoid common pitfalls other developers struggle with. She offers expert strategies for working with this immensely powerful language, taking into account Swift’s rapid evolution and its migration tools.

Whether you’re moving to modern Swift from Objective-C, from older versions of the Swift language, or from the world of non-Apple languages, this guide will help you master both the “how” and “why” of effective Swift development. Industry recruiters are scrambling to find Swift developers who can solve real problems and produce effective working code. Get this book, and you’ll be ready.

Coverage includes


Writing effective Swift code that communicates clearly and coherently to the compiler, your team, and to “future you,” who will be maintaining this code
Using Xcode to handle changes in Swift’s language constructs as the language evolves
Building feedback, documentation, and output to meet your development and debugging needs
Making the most of optionals and their supporting constructs
Using closures to encapsulate state and functionality and treat actions as variables for later execution
Leveraging control flow with innovative Swift-specific statements
Working with all Swift types: classes, enumerations, and structures
Using generics and protocols to build robust code that expands functionality beyond single types
Making the most of the powerful Swift error system
Working with innovative features such as array indexing, general subscripting, statement labels, custom operators, and more




This book is part of the Pearson Content Update Program (CUP). As the technology changes, sections of this book will be updated or new sections will be added. The updates will be delivered to you via a free Web Edition of this book, which can be accessed with any Internet connection.

Erica Sadun is a bestselling author, coauthor, and contributor to several dozen books on programming and other digital topics. She has blogged at TUAW.com, O'Reilly's Mac Devcenter, Lifehacker, and Ars Technica. In addition to being the author of dozens of iOS-native applications, Erica holds a Ph.D. in computer science from Georgia Tech's Graphics, Visualization and Usability Center. A geek, a programmer, and an author, she's never met a gadget she didn't love. When not writing, she and her geek husband have parented three geeks-in-training, who regard their parents with restrained bemusement, when they're not busy rewiring the house or plotting global domination.

Preface   xiii
How This Book Is Organized   xiii
About the Sample Code   xiv
Contacting the Author   xv
Chapter 1: Welcome to Modern Swift    1
Migrating Code    2
How to Migrate    2
Migration Lessons    4
Using Swift    4
Compiled Applications    4
Frameworks and Libraries    5
Scripting    5
REPL    6
Playgrounds    7
Other Swift    8
Learning Swift    8
Wrap-up    9
Chapter 2: Printing and Mirroring    11
Basic Printing    11
Printing Multiple Items    12
Adding Item Separators    13
String Interpolation    13
Controlling Line Feeds    14
Recipe: Printing to Custom Destinations    15
Printing to Strings    16
Printing to Custom Output Streams    17
Recipe: Printing and String Formats    18
Swift and Format Specifiers    19
Format Limitations    19
Conditional Compilation    20
Debug Printing    21
Custom Stream Output    21
Recipe: Postfix Printing    23
Quick Looks    24
Quick Look for Custom Types    24
Quick Looks for Custom Types in Playgrounds    25
Playground Quick Looks    25
Creating Custom Quick Looks for Playgrounds    26
Built-in Quick Look Types    27
Third-Party Rendering    28
Using Dump Functions    30
Building Custom Mirrors    31
Recursive Reflection    32
Building Basic Mirror Descriptions Using Protocol Conformance    33
Adding Header Docs    35
Building Header Documentation    35
Markdown Support    36
Keywords    37
Special Swift Concerns    40
Adding Images to Header Docs    40
Wrap-up    41
Chapter 3: Optionals?!    43
Optionals 101    43
Unwrapping Optionals    45
Forced Unwrapping    45
Conditional Binding    46
Conditional Binding and Type Casts    46
Binding Cascades    48
guard Statements    50
Implicitly Unwrapped Optionals    51
Guarding Failable Initializers    52
Optionals and Sentinel Values    53
Coalescing    55
Optional Assignment    55
Optional Patterns    56
Optional Chaining    58
Selector Testing and Optional Chaining    59
Subscripts    60
Optional Mapping    61
Maps and Chaining    61
Filtering nil Values with flatMap    62
Unmanaged Wrappers    62
Wrap-up    64
Chapter 4: Closures and Functions    65
Building a Function    65
Parameter Names    66
Label Conventions    66
Naming Methods and Functions    68
External and Local Parameters    69
Defaults    70
Constant and Variable Parameters    71
Modifying Parameters    72
Closures and Functions    73
Function Types    73
Using Tuple Arguments    74
Using Shorthand Argument Names    74
Inferred Closure Types    76
Parameter Type Inference    77
Declaring Type Aliases    78
Nested Functions    79
Tuples    80
From Tuples to Structs    82
Tuple Return Types    82
Variadic Parameters    83
Capturing Values    85
Autoclosures    87
Adding Default Closures    90
Currying    91
Why Curry?    92
Building Libraries    92
Partial Application    93
Currying Costs    94
Currying and Callbacks    94
Practical Currying    95
Passing Closures as Function Parameters    97
Wrap-up    99
Chapter 5: Generics and Protocols    101
Expanding to Generics    101
Protocols    102
Tokens    103
Type Constraints    104
Adopting Protocols    104
Declaring Protocols    105
Member Declarations    107
Building a Basic Protocol    109
Adding Protocol Default Implementations    110
Optional Protocol Requirements    111
Swift-Native Optional Protocol Requirements    112
Building Generic Types    113
Type Parameters    113
Generic Requirements    114
Conformance Requirements    115
Recipe: Same-Type Requirements    115
Generic Beautification    117
Legal Tokens    117
Matching Aliases    118
Protocol Alias Defaults    119
Collating Associated Types    119
Extending Generic Types    120
Using Protocols as Types    121
Protocol-Based Collections    121
Self Requirements    122
Protocol Objects and Self Requirements    123
Leveraging Protocols    124
Wrap-up    124
Chapter 6: Errors    125
Failing Hard    125
Fatal Errors    126
Assertions    126
Preconditions    127
Aborting and Exiting    128
Failing Gracefully    128
The ErrorType Protocol    129
Choosing Between Optionals and Error Handling    130
Swift Error Rules    130
Rule 1: Move Away from nil Sentinels    131
Rule 2: Use throw to Raise Errors    132
Rule 3: Use Error Types with Visible Access    133
Rule 4: Mark All Error-Participating Methods with throws    134
Rule 5: Use rethrows Consistently    134
Rule 6: Consume Errors Where They Matter    135
Rule 7: Terminate Threaded Error Chains    135
Building Errors    137
Good Errors    138
Naming Your Errors    138
Adding String Descriptions    139
Adding Reasons    139
Simplifying Output    140
Extending String    140
Type-Specific Errors    141
Retrieving Context    141
Contextualizing Strings    142
Contextualizing Throwing Types    143
Simplifying Contexts    144
Calling Throwing Functions    145
Using try    145
Error Propagation    147
Using try!    148
Using try?    148
Implementing Alternatives to try?    149
Guarding Results    151
Building a Printing Version of try?    151
Working with guard and defer    151
Wrap-up    153
Chapter 7: Types    155
Language Concepts    155
Reference and Value Types    155
Copy-and-Write-Back    156
Algebraic Data Types    157
Other Terminology    158
Enumerations    159
Basic Enumerations    159
Using Hash Values to Support Ranges    160
Raw Value Enumerations    162
Raw Value Members and Sequences    163
Associated Values    164
Indirect Values    165
Switches    166
Branching    166
Breaks    167
Fallthroughs    167
Complex Cases    169
Tuples    169
Pattern Matching with Value Bindings    169
where Clauses    170
Unwrapping Optional Enumerations    171
Embedding Values by Type    172
Option Sets    174
Revisiting NS_OPTIONS    174
Building Enumerations    175
Building Option Sets    176
Viewing Options    176
Classes    177
Optimization    178
Initializers    178
Initialization Steps    179
Designated and Convenience Initializers    179
Initialization Rules    179
Building Convenience Initializers    181
Failable and Throwing Initializers    181
Deinitializers    183
Property Observers    184
Getters/Setters and Access-Level Modifiers    185
Extensions and Overrides    186
Lazy Evaluation    187
Lazy Sequences    187
Lazy Properties    188
Wrap-up    188
Chapter 8: Miscellany    189
Statement Labels    189
Custom Operators    190
Declaring Operators    191
Conforming with Operators    192
Evaluating Operator Trade-offs    192
Array Indexing    193
Multi-indexed Array Access    194
Wrapped Indices    195
Array Slices    195
General Subscripting    196
Parameter-less Subscripting    197
String Utilities    198
Repeat Initializers    198
Strings and Radix    198
String Ranges    199
String Splitting    201
String Subscripts    201
Foundation Interoperability    203
Joining and Extending    203
Permutation Generator    203
Wrap-up    205
Index    207

Erscheint lt. Verlag 24.12.2015
Verlagsort New Jersey
Sprache englisch
Maße 179 x 228 mm
Gewicht 388 g
Themenwelt Informatik Programmiersprachen / -werkzeuge Mac / Cocoa Programmierung
Informatik Software Entwicklung Mobile- / App-Entwicklung
Informatik Weitere Themen Smartphones / Tablets
Technik Nachrichtentechnik
ISBN-10 0-13-439526-3 / 0134395263
ISBN-13 978-0-13-439526-5 / 9780134395265
Zustand Neuware
Haben Sie eine Frage zum Produkt?
Mehr entdecken
aus dem Bereich
Apps programmieren für macOS, iOS, watchOS und tvOS

von Thomas Sillmann

Buch (2023)
Carl Hanser (Verlag)
59,99
Das umfassende Handbuch. Apps entwickeln für iOS, macOS und tvOS. …

von Michael Kofler

Buch | Hardcover (2019)
Rheinwerk (Verlag)
49,90
The Big Nerd Ranch Guide

von Matthew Mathias; Mikey Ward; John Gallagher

Buch | Softcover (2020)
Big Nerd Ranch Guides (Verlag)
48,75