book

Mastering Swift 5.3 - Sixth Edition

Name: Mastering Swift 5.3 - Sixth Edition
Author: Jon Hoffman
ISBN: 9781800562158

by Jon Hoffman

November 2020

Beginner

418 pages

9h 9m

English

Packt Publishing

Read now

Unlock full access

Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchReviews
Taking the First Steps with Swift
What is Swift?Swift featuresPlaygroundsGetting started with playgroundsiOS, tvOS, and macOS playgroundsCreating and displaying graphs in playgroundsWhat playgrounds are notSwift language syntaxCommentsSemicolonsParenthesesCurly bracketsAn assignment operator does not return a valueSpaces are optional in conditional and assignment statementsHello WorldSummary
Swift Documentation and Installing Swift
Swift.orgSwift documentationInstalling Swift from swift.orgBuilding Swift and the Swift toolchain from sourceInstalling dependenciesSwift sourceBuilding Swift Installing SwiftTesting the installationUsing the Swift package managerUsing the Swift compilerSummary
Learning about Variables, Constants, Strings, and Operators
Constants and variablesDefining constants and variablesType safetyType inferenceExplicit typesNumeric typesInteger typesFloating-point and Double valuesThe Boolean typeThe String typeTuplesEnumerationsOperatorsThe assignment operatorComparison operatorsArithmetic operatorsThe remainder operatorCompound assignment operatorsThe closed range operatorThe half-open range operatorThe ternary conditional operatorThe logical NOT operatorThe logical AND operatorThe logical OR operatorSummary
Optional Types
Introducing optionalsThe need for optional types in SwiftDefining an optionalUsing optionalsForced unwrapping of an optionalOptional bindingOptional types with tuplesOptional chainingThe nil coalescing operatorSummary
Using Swift Collections
Swift collection typesMutabilityArraysCreating and initializing arraysAccessing the array elementCounting the elements of an arrayIs the array empty?Shuffling an arrayAppending to an arrayInserting a value into an arrayReplacing elements in an arrayRemoving elements from an arrayMerging two arraysRetrieving a subarray from an arrayMaking bulk changes to an arrayAlgorithms for arraysSortSortedFilterMapCountDiffforEachIterating over an arrayDictionariesCreating and initializing dictionariesAccessing dictionary valuesCounting the keys or values in a dictionaryIs the dictionary empty?Updating the value of a keyAdding a key-value pairRemoving a key-value pairSetInitializing a setInserting items into a setDetermining the number of items in a setChecking whether a set contains an itemIterating over a setRemoving items in a setSet operationsSummary
Control Flow
What have we learned so far?Curly bracketsParenthesesControl flowConditional statementsThe if statementConditional code execution with the if...else statementThe guard statementThe switch statementMatch on wildcardLoopsThe for-in loopUsing the for-in loopThe while loopUsing the while loopUsing the repeat-while loopUsing case and where statements with conditional statements and loopsFiltering with the where statementFiltering with the for-case statementUsing the if-case statementControl transfer statementsThe continue statementThe break statementThe fallthrough statementSummary
Functions
Using a single-parameter functionUsing a multi-parameter functionDefining a parameter's default valuesReturning multiple values from a functionAdding external parameter namesUsing variadic parametersinout parametersOmitting argument labelsPutting it all togetherSummary
Classes, Structures, and Protocols
What are classes and structures?Similarities between classes and structuresDifferences between classes and structuresValue versus reference typesCreating a class or structurePropertiesStored propertiesComputed propertiesProperty observersMethodsCustom initializersInternal and external parameter namesFailable initializersAccess controlsKey-path expressions as functionsCalling a type as a functionInheritanceOverriding methods and propertiesOverriding methodsOverriding propertiesPreventing overridesProtocolsProtocol syntaxProperty requirementsMethod requirementsExtensionsProperty wrappersOptional chainingSummary
Protocols and Protocol Extensions
Protocols as typesPolymorphism with protocolsTypecasting with protocolsProtocol extensionsA real-world exampleDo I need to use protocols?Adopting protocols using a synthesized implementationSwift's standard librarySummary

Protocol-Oriented Design
RequirementsObject-oriented designProtocol-oriented designProtocol inheritanceProtocol compositionProtocol-oriented design – putting it all togetherUsing the where statement with protocolsStructures versus classesSummary
Generics
Introducing genericsGeneric functionsGeneric typesConditionally adding extensions with genericsConditionally adding functionsConditional conformanceGeneric subscriptsAssociated typesSummary
Error Handling and Availability
Native error handlingRepresenting errorsThrowing errorsCatching errorsMulti-pattern catch clausesThe availability attributeSummary
Custom Subscripting
Introducing subscriptsSubscripts with Swift arraysCreating and using custom subscriptsRead-only custom subscriptsCalculated subscriptsSubscript valuesStatic subscriptsExternal names for subscriptsMultidimensional subscriptsDynamic member lookupWhen not to use a custom subscriptSummary
Working with Closures
An introduction to closuresSimple closuresShorthand syntax for closuresUsing closures with Swift arraysUsing closures with Swift's array algorithmsNon-contiguous elements from an arrayUninitialized arraysChanging functionalitySelecting a closure based on resultsSummary
Advanced and Custom Operators
Bits and bytesEndiannessBitwise operatorsPrinting binary numbersThe bitwise AND operatorThe bitwise OR operatorThe bitwise XOR operatorThe bitwise NOT operatorBitwise shift operatorsOverflow operatorsOperator methodsCustom operatorsSummary
Concurrency and Parallelism in Swift
Concurrency and parallelismGrand Central Dispatch (GCD)Calculation typesCreating queuesCreating and using a concurrent queueCreating and using a serial queueasync versus syncExecuting code on the main queue functionUsing asyncAfterUsing the Operation and OperationQueue typesUsing BlockOperationUsing the addOperation() method of the operation queueSubclassing the Operation classSummary
Custom Value Types
Value types and reference typesRecursive data types for reference typesInheritance for reference typesDynamic dispatchCopy-on-writeImplementing the Equatable protocolSummary
Memory Management
How ARC worksStrong reference cyclesUnowned referencesWeak referencesSummary
Swift Formatting and Style Guide
What is a programming style guide?API Design GuideYour style guideDo not use semicolons at the end of statementsDo not use parentheses for conditional statementsNamingIndentingCommentsUsing the self keywordConstants and variablesOptional typesUsing type inferenceUsing shorthand declarations for collectionsUsing switch rather than multiple if statementsDon't leave commented-out code in your applicationSummary
Adopting Design Patterns in Swift
What are design patterns?Creational design patternsThe singleton patternUnderstanding the problemUnderstanding the solutionImplementing the singleton patternThe builder patternUnderstanding the problemUnderstanding the solutionImplementing the builder patternStructural design patternsThe bridge patternUnderstanding the problemUnderstanding the solutionImplementing the bridge patternThe facade patternUnderstanding the problemUnderstanding the solutionImplementing the facade patternThe proxy patternUnderstanding the problemUnderstanding the solutionImplementing the proxy patternBehavioral design patternsThe command patternUnderstanding the problemUnderstanding the solutionImplementing the command patternThe strategy patternUnderstanding the problemUnderstanding the solutionImplementing the strategy patternSummary
Other Books You May Enjoy
Index

Overview

Delve into the advanced features of Swift 5.3 with 'Mastering Swift 5.3', a comprehensive and revised guide to Apple's versatile programming language. From core concepts to advanced topics like protocol-oriented programming and memory management, this book equips you with the tools to write efficient, robust, and Swift-compliant applications.

What this Book will help me do

Gain a thorough understanding of core Swift features such as operators, control flows, and functions.
Master protocol-oriented programming to write flexible and reusable code.
Learn to apply design patterns specifically tailored for Swift applications.
Develop expertise in handling concurrency through Grand Central Dispatch.
Optimize performance with techniques like copy-on-write for custom value types.

Author(s)

Jon Hoffman is a software engineer with over two decades of experience in software development and a proven track record in teaching programming concepts. He specializes in Swift and has written for several technical platforms and publications. His unique teaching style combines practice-oriented lessons with detailed theoretical explanations.

Who is it for?

This book is best suited for programmers with some coding experience seeking to specialize in Swift or enhance existing Swift skills. It's also perfect for developers aiming to understand protocol-oriented programming and advanced Swift features. Whether you're building apps for iOS, macOS, or server-side Swift, this guide will elevate your capabilities. Desktop tool developers will also find value in its comprehensive coverage of Swift's core features.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781800562158

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills