Mastering Swift 5.3 - Jon Hoffman Katowice

Over the years, Mastering Swift has proven itself among developers as a popular choice for an in-depth and practical guide to the Swift programming language. This sixth edition comes with the latest features, an overall revision to align with Swift 5.3, and two new chapters on building swift from source and advanced operators. From the basics of the language to popular features such as concurrency, generics, and memory management, this in-depth guide will help you develop your expertise and mastery of the language. As you progress, you will gain practical insights into some of the most sophisticated elements in Swift development, including protocol extensions, error handling, and closures. The book will also show you how to use and apply them in your own projects. In later chapters, you will understand how to use the power of protocol-oriented programming to write flexible and easier-to-manage code in Swift. Finally, you will learn how to add the copy-on-write feature to your custom value types, along with understanding how to avoid memory management issues caused by strong reference cycles. By the end of this Swift book, you will have mastered the Swift 5.3 language and developed the skills you need to effectively use its features to build robust applications. Spis treści: Preface Who this book is for What this book covers To get the most out of this book Download the example code files Download the color images Conventions used Get in touch Reviews Taking the First Steps with Swift What is Swift? Swift features Playgrounds Getting started with playgrounds iOS, tvOS, and macOS playgrounds Creating and displaying graphs in playgrounds What playgrounds are not Swift language syntax Comments Semicolons Parentheses Curly brackets An assignment operator does not return a value Spaces are optional in conditional and assignment statements Hello World Summary Swift Documentation and Installing Swift Swift.org Swift documentation Installing Swift from swift.org Building Swift and the Swift toolchain from source Installing dependencies Swift source Building Swift Installing Swift Testing the installation Using the Swift package manager Using the Swift compiler Summary Learning about Variables, Constants, Strings, and Operators Constants and variables Defining constants and variables Type safety Type inference Explicit types Numeric types Integer types Floating-point and Double values The Boolean type The String type Tuples Enumerations Operators The assignment operator Comparison operators Arithmetic operators The remainder operator Compound assignment operators The closed range operator The half-open range operator The ternary conditional operator The logical NOT operator The logical AND operator The logical OR operator Summary Optional Types Introducing optionals The need for optional types in Swift Defining an optional Using optionals Forced unwrapping of an optional Optional binding Optional types with tuples Optional chaining The nil coalescing operator Summary Using Swift Collections Swift collection types Mutability Arrays Creating and initializing arrays Accessing the array element Counting the elements of an array Is the array empty? Shuffling an array Appending to an array Inserting a value into an array Replacing elements in an array Removing elements from an array Merging two arrays Retrieving a subarray from an array Making bulk changes to an array Algorithms for arrays Sort Sorted Filter Map Count Diff forEach Iterating over an array Dictionaries Creating and initializing dictionaries Accessing dictionary values Counting the keys or values in a dictionary Is the dictionary empty? Updating the value of a key Adding a key-value pair Removing a key-value pair Set Initializing a set Inserting items into a set Determining the number of items in a set Checking whether a set contains an item Iterating over a set Removing items in a set Set operations Summary Control Flow What have we learned so far? Curly brackets Parentheses Control flow Conditional statements The if statement Conditional code execution with the if...else statement The guard statement The switch statement Match on wildcard Loops The for-in loop Using the for-in loop The while loop Using the while loop Using the repeat-while loop Using case and where statements with conditional statements and loops Filtering with the where statement Filtering with the for-case statement Using the if-case statement Control transfer statements The continue statement The break statement The fallthrough statement Summary Functions Using a single-parameter function Using a multi-parameter function Defining a parameters default values Returning multiple values from a function Adding external parameter names Using variadic parameters inout parameters Omitting argument labels Putting it all together Summary Classes, Structures, and Protocols What are classes and structures? Similarities between classes and structures Differences between classes and structures Value versus reference types Creating a class or structure Properties Stored properties Computed properties Property observers Methods Custom initializers Internal and external parameter names Failable initializers Access controls Key-path expressions as functions Calling a type as a function Inheritance Overriding methods and properties Overriding methods Overriding properties Preventing overrides Protocols Protocol syntax Property requirements Method requirements Extensions Property wrappers Optional chaining Summary Protocols and Protocol Extensions Protocols as types Polymorphism with protocols Typecasting with protocols Protocol extensions A real-world example Do I need to use protocols? Adopting protocols using a synthesized implementation Swift's standard library Summary Protocol-Oriented Design Requirements Object-oriented design Protocol-oriented design Protocol inheritance Protocol composition Protocol-oriented design putting it all together Using the where statement with protocols Structures versus classes Summary Generics Introducing generics Generic functions Generic types Conditionally adding extensions with generics Conditionally adding functions Conditional conformance Generic subscripts Associated types Summary Error Handling and Availability Native error handling Representing errors Throwing errors Catching errors Multi-pattern catch clauses The availability attribute Summary Custom Subscripting Introducing subscripts Subscripts with Swift arrays Creating and using custom subscripts Read-only custom subscripts Calculated subscripts Subscript values Static subscripts External names for subscripts Multidimensional subscripts Dynamic member lookup When not to use a custom subscript Summary Working with Closures An introduction to closures Simple closures Shorthand syntax for closures Using closures with Swift arrays Using closures with Swift's array algorithms Non-contiguous elements from an array Uninitialized arrays Changing functionality Selecting a closure based on results Summary Advanced and Custom Operators Bits and bytes Endianness Bitwise operators Printing binary numbers The bitwise AND operator The bitwise OR operator The bitwise XOR operator The bitwise NOT operator Bitwise shift operators Overflow operators Operator methods Custom operators Summary Concurrency and Parallelism in Swift Concurrency and parallelism Grand Central Dispatch (GCD) Calculation types Creating queues Creating and using a concurrent queue Creating and using a serial queue async versus sync Executing code on the main queue function Using asyncAfter Using the Operation and OperationQueue types Using BlockOperation Using the addOperation() method of the operation queue Subclassing the Operation class Summary Custom Value Types Value types and reference types Recursive data types for reference types Inheritance for reference types Dynamic dispatch Copy-on-write Implementing the Equatable protocol Summary Memory Management How ARC works Strong reference cycles Unowned references Weak references Summary Swift Formatting and Style Guide What is a programming style guide? API Design Guide Your style guide Do not use semicolons at the end of statements Do not use parentheses for conditional statements Naming Indenting Comments Using the self keyword Constants and variables Optional types Using type inference Using shorthand declarations for collections Using switch rather than multiple if statements Don't leave commented-out code in your application Summary Adopting Design Patterns in Swift What are design patterns? Creational design patterns The singleton pattern Understanding the problem Understanding the solution Implementing the singleton pattern The builder pattern Understanding the problem Understanding the solution Implementing the builder pattern Structural design patterns The bridge pattern Understanding the problem Understanding the solution Implementing the bridge pattern The facade pattern Understanding the problem Understanding the solution Implementing the facade pattern The proxy pattern Understanding the problem Understanding the solution Implementing the proxy pattern Behavioral design patterns The command pattern Understanding the problem Understanding the solution Implementing the command pattern The strategy pattern Understanding the problem Understanding the solution Implementing the strategy pattern Summary Other Books You May Enjoy Index O autorze: Jon Hoffman od ponad ćwierćwiecza zajmuje się administrowaniem systemami i sieciami oraz ich bezpieczeństwem, a także tworzeniem aplikacji i architekturą systemów. Od 2008 roku tworzy oprogramowanie na platformę iOS. Jego prawdziwą pasją jest podejmowanie wyzwań w zakresie technologii informatycznych i oczywiście pokonywanie napotkanych problemów.