Swift Notes for Professionals (GoalKicker.com) (Z-Library)

Swift Notes for ProfessionalsSwift™ Notes for Professionals GoalKicker.com Free Programming Books Disclaimer This is an unocial free book created for educational purposes and is not aliated with ocial Swift™ group(s) or company(s). All trademarks and registered trademarks are the property of their respective owners 200+ pages of professional hints and tricks

Contents About 1 ................................................................................................................................................................................... Chapter 1: Getting started with Swift Language 2 .......................................................................................... Section 1.1: Your first Swift program 2 ............................................................................................................................ Section 1.2: Your first program in Swift on a Mac (using a Playground) 3 ................................................................. Section 1.3: Your first program in Swift Playgrounds app on iPad 7 ........................................................................... Section 1.4: Installing Swift 8 ............................................................................................................................................ Section 1.5: Optional Value and Optional enum 8 ......................................................................................................... Chapter 2: Variables & Properties 10 ..................................................................................................................... Section 2.1: Creating a Variable 10 ................................................................................................................................. Section 2.2: Property Observers 10 ................................................................................................................................ Section 2.3: Lazy Stored Properties 11 ........................................................................................................................... Section 2.4: Property Basics 11 ....................................................................................................................................... Section 2.5: Computed Properties 12 ............................................................................................................................. Section 2.6: Local and Global Variables 12 ................................................................................................................... Section 2.7: Type Properties 13 ....................................................................................................................................... Chapter 3: Numbers 14 .................................................................................................................................................. Section 3.1: Number types and literals 14 ...................................................................................................................... Section 3.2: Convert numbers to/from strings 15 ........................................................................................................ Section 3.3: Rounding 15 .................................................................................................................................................. Section 3.4: Random number generation 16 ................................................................................................................. Section 3.5: Convert one numeric type to another 17 .................................................................................................. Section 3.6: Exponentiation 17 ........................................................................................................................................ Chapter 4: Strings and Characters 18 ................................................................................................................... Section 4.1: String & Character Literals 18 ..................................................................................................................... Section 4.2: Concatenate strings 19 ............................................................................................................................... Section 4.3: String Encoding and Decomposition 20 .................................................................................................... Section 4.4: Examine and compare strings 20 .............................................................................................................. Section 4.5: Reversing Strings 21 .................................................................................................................................... Section 4.6: Check if String contains Characters from a Defined Set 21 .................................................................... Section 4.7: String Iteration 22 ........................................................................................................................................ Section 4.8: Splitting a String into an Array 24 .............................................................................................................. Section 4.9: Unicode 24 .................................................................................................................................................... Section 4.10: Converting Swift string to a number type 25 .......................................................................................... Section 4.11: Convert String to and from Data / NSData 25 ........................................................................................ Section 4.12: Formatting Strings 26 ................................................................................................................................ Section 4.13: Uppercase and Lowercase Strings 26 ...................................................................................................... Section 4.14: Remove characters from a string not defined in Set 27 ........................................................................ Section 4.15: Count occurrences of a Character into a String 27 ................................................................................ Section 4.16: Remove leading and trailing WhiteSpace and NewLine 27 ................................................................... Chapter 5: Booleans 29 .................................................................................................................................................. Section 5.1: What is Bool? 29 ........................................................................................................................................... Section 5.2: Booleans and Inline Conditionals 29 .......................................................................................................... Section 5.3: Boolean Logical Operators 30 .................................................................................................................... Section 5.4: Negate a Bool with the prefix ! operator 30 .............................................................................................. Chapter 6: Arrays 31 ....................................................................................................................................................... Section 6.1: Basics of Arrays 31 ....................................................................................................................................... Section 6.2: Extracting values of a given type from an Array with flatMap(_:) 32 ...................................................

Section 6.3: Combining an Array's elements with reduce(_:combine:) 32 ................................................................. Section 6.4: Flattening the result of an Array transformation with flatMap(_:) 33 ................................................... Section 6.5: Lazily flattening a multidimensional Array with flatten() 33 ................................................................... Section 6.6: Filtering out nil from an Array transformation with flatMap(_:) 34 ....................................................... Section 6.7: Subscripting an Array with a Range 34 ..................................................................................................... Section 6.8: Removing element from an array without knowing it's index 35 ........................................................... Section 6.9: Sorting an Array of Strings 35 .................................................................................................................... Section 6.10: Accessing indices safely 36 ....................................................................................................................... Section 6.11: Filtering an Array 37 ................................................................................................................................... Section 6.12: Transforming the elements of an Array with map(_:) 37 ...................................................................... Section 6.13: Useful Methods 38 ...................................................................................................................................... Section 6.14: Sorting an Array 38 .................................................................................................................................... Section 6.15: Finding the minimum or maximum element of an Array 39 ................................................................. Section 6.16: Modifying values in an array 40 ............................................................................................................... Section 6.17: Comparing 2 Arrays with zip 40 ................................................................................................................ Section 6.18: Grouping Array values 41 .......................................................................................................................... Section 6.19: Value Semantics 42 .................................................................................................................................... Section 6.20: Accessing Array Values 42 ....................................................................................................................... Chapter 7: Tuples 44 ........................................................................................................................................................ Section 7.1: What are Tuples? 44 .................................................................................................................................... Section 7.2: Decomposing into individual variables 44 ................................................................................................ Section 7.3: Tuples as the Return Value of Functions 45 ............................................................................................. Section 7.4: Using a typealias to name your tuple type 45 ......................................................................................... Section 7.5: Swapping values 46 ..................................................................................................................................... Section 7.6: Tuples as Case in Switch 46 ........................................................................................................................ Chapter 8: Enums 48 ....................................................................................................................................................... Section 8.1: Basic enumerations 48 ................................................................................................................................. Section 8.2: Enums with associated values 48 .............................................................................................................. Section 8.3: Indirect payloads 49 .................................................................................................................................... Section 8.4: Raw and Hash values 50 ............................................................................................................................ Section 8.5: Initializers 51 ................................................................................................................................................. Section 8.6: Enumerations share many features with classes and structures 52 ..................................................... Section 8.7: Nested Enumerations 53 ............................................................................................................................. Chapter 9: Structs 54 ...................................................................................................................................................... Section 9.1: Structs are value types 54 ........................................................................................................................... Section 9.2: Accessing members of struct 54 ................................................................................................................ Section 9.3: Basics of Structs 54 ..................................................................................................................................... Section 9.4: Mutating a Struct 55 .................................................................................................................................... Section 9.5: Structs cannot inherit 55 ............................................................................................................................. Chapter 10: Sets 57 ........................................................................................................................................................... Section 10.1: Declaring Sets 57 ........................................................................................................................................ Section 10.2: Performing operations on sets 57 ............................................................................................................ Section 10.3: CountedSet 58 ............................................................................................................................................. Section 10.4: Modifying values in a set 58 ...................................................................................................................... Section 10.5: Checking whether a set contains a value 58 ........................................................................................... Section 10.6: Adding values of my own type to a Set 58 .............................................................................................. Chapter 11: Dictionaries 60 ........................................................................................................................................... Section 11.1: Declaring Dictionaries 60 ............................................................................................................................ Section 11.2: Accessing Values 60 .................................................................................................................................... Section 11.3: Change Value of Dictionary using Key 61 ................................................................................................

Section 11.4: Get all keys in Dictionary 61 ....................................................................................................................... Section 11.5: Modifying Dictionaries 61 ........................................................................................................................... Section 11.6: Merge two dictionaries 62 .......................................................................................................................... Chapter 12: Switch 63 ...................................................................................................................................................... Section 12.1: Switch and Optionals 63 ............................................................................................................................. Section 12.2: Basic Use 63 ................................................................................................................................................ Section 12.3: Matching a Range 63 ................................................................................................................................. Section 12.4: Partial matching 64 .................................................................................................................................... Section 12.5: Using the where statement in a switch 65 ............................................................................................... Section 12.6: Matching Multiple Values 65 ...................................................................................................................... Section 12.7: Switch and Enums 66 ................................................................................................................................. Section 12.8: Switches and tuples 66 .............................................................................................................................. Section 12.9: Satisfy one of multiple constraints using switch 67 ................................................................................ Section 12.10: Matching based on class - great for prepareForSegue 67 .................................................................. Section 12.11: Switch fallthroughs 68 ............................................................................................................................... Chapter 13: Optionals 69 ................................................................................................................................................ Section 13.1: Types of Optionals 69 ................................................................................................................................. Section 13.2: Unwrapping an Optional 69 ...................................................................................................................... Section 13.3: Nil Coalescing Operator 71 ........................................................................................................................ Section 13.4: Optional Chaining 71 .................................................................................................................................. Section 13.5: Overview - Why Optionals? 72 .................................................................................................................. Chapter 14: Conditionals 74 ......................................................................................................................................... Section 14.1: Optional binding and "where" clauses 74 ................................................................................................. Section 14.2: Using Guard 75 ........................................................................................................................................... Section 14.3: Basic conditionals: if-statements 75 ......................................................................................................... Section 14.4: Ternary operator 76 ................................................................................................................................... Section 14.5: Nil-Coalescing Operator 77 ....................................................................................................................... Chapter 15: Error Handling 78 .................................................................................................................................... Section 15.1: Error handling basics 78 ............................................................................................................................. Section 15.2: Catching dierent error types 79 ............................................................................................................. Section 15.3: Catch and Switch Pattern for Explicit Error Handling 80 ........................................................................ Section 15.4: Disabling Error Propagation 81 ................................................................................................................ Section 15.5: Create custom Error with localized description 81 ................................................................................. Chapter 16: Loops 83 ....................................................................................................................................................... Section 16.1: For-in loop 83 ............................................................................................................................................... Section 16.2: Repeat-while loop 85 ................................................................................................................................. Section 16.3: For-in loop with filtering 85 ........................................................................................................................ Section 16.4: Sequence Type forEach block 86 ............................................................................................................. Section 16.5: while loop 86 ............................................................................................................................................... Section 16.6: Breaking a loop 87 ..................................................................................................................................... Chapter 17: Protocols 88 ................................................................................................................................................ Section 17.1: Protocol Basics 88 ....................................................................................................................................... Section 17.2: Delegate pattern 90 ................................................................................................................................... Section 17.3: Associated type requirements 91 ............................................................................................................. Section 17.4: Class-Only Protocols 93 ............................................................................................................................. Section 17.5: Protocol extension for a specific conforming class 94 ........................................................................... Section 17.6: Using the RawRepresentable protocol (Extensible Enum) 94 ............................................................... Section 17.7: Implementing Hashable protocol 95 ........................................................................................................ Chapter 18: Functions 97 ...............................................................................................................................................

Section 18.1: Basic Use 97 ................................................................................................................................................. Section 18.2: Functions with Parameters 97 ................................................................................................................... Section 18.3: Subscripts 98 ............................................................................................................................................... Section 18.4: Methods 99 .................................................................................................................................................. Section 18.5: Variadic Parameters 100 ........................................................................................................................... Section 18.6: Operators are Functions 100 .................................................................................................................... Section 18.7: Passing and returning functions 101 ........................................................................................................ Section 18.8: Function types 101 ..................................................................................................................................... Section 18.9: Inout Parameters 101 ................................................................................................................................ Section 18.10: Throwing Errors 101 ................................................................................................................................. Section 18.11: Returning Values 102 ................................................................................................................................ Section 18.12: Trailing Closure Syntax 102 ..................................................................................................................... Section 18.13: Functions With Closures 103 .................................................................................................................... Chapter 19: Extensions 105 ........................................................................................................................................... Section 19.1: What are Extensions? 105 .......................................................................................................................... Section 19.2: Variables and functions 105 ...................................................................................................................... Section 19.3: Initializers in Extensions 106 ...................................................................................................................... Section 19.4: Subscripts 106 ............................................................................................................................................. Section 19.5: Protocol extensions 106 ............................................................................................................................. Section 19.6: Restrictions 107 .......................................................................................................................................... Section 19.7: What are extensions and when to use them 107 .................................................................................... Chapter 20: Classes 109 ................................................................................................................................................. Section 20.1: Defining a Class 109 .................................................................................................................................. Section 20.2: Properties and Methods 109 .................................................................................................................... Section 20.3: Reference Semantics 109 ......................................................................................................................... Section 20.4: Classes and Multiple Inheritance 110 ...................................................................................................... Section 20.5: deinit 111 .................................................................................................................................................... Chapter 21: Type Casting 112 ...................................................................................................................................... Section 21.1: Downcasting 112 ......................................................................................................................................... Section 21.2: Type casting in Swift Language 112 ........................................................................................................ Section 21.3: Upcasting 114 ............................................................................................................................................. Section 21.4: Example of using a downcast on a function parameter involving subclassing 114 ........................... Section 21.5: Casting with switch 115 .............................................................................................................................. Chapter 22: Generics 116 ............................................................................................................................................... Section 22.1: The Basics of Generics 116 ....................................................................................................................... Section 22.2: Constraining Generic Placeholder Types 117 ........................................................................................ Section 22.3: Generic Class Examples 118 ..................................................................................................................... Section 22.4: Using Generics to Simplify Array Functions 119 .................................................................................... Section 22.5: Advanced Type Constraints 119 .............................................................................................................. Section 22.6: Generic Class Inheritance 120 .................................................................................................................. Section 22.7: Use generics to enhance type-safety 121 .............................................................................................. Chapter 23: OptionSet 122 ............................................................................................................................................ Section 23.1: OptionSet Protocol 122 .............................................................................................................................. Chapter 24: Reading & Writing JSON 123 ............................................................................................................ Section 24.1: JSON Serialization, Encoding, and Decoding with Apple Foundation and the Swift Standard Library 123 ................................................................................................................................................................ Section 24.2: SwiftyJSON 126 ......................................................................................................................................... Section 24.3: Freddy 127 ................................................................................................................................................. Section 24.4: JSON Parsing Swift 3 129 ......................................................................................................................... Section 24.5: Simple JSON parsing into custom objects 131 ......................................................................................

Section 24.6: Arrow 132 ................................................................................................................................................... Chapter 25: Advanced Operators 135 .................................................................................................................... Section 25.1: Bitwise Operators 135 ................................................................................................................................ Section 25.2: Custom Operators 136 .............................................................................................................................. Section 25.3: Overflow Operators 137 ........................................................................................................................... Section 25.4: Commutative Operators 137 .................................................................................................................... Section 25.5: Overloading + for Dictionaries 138 .......................................................................................................... Section 25.6: Precedence of standard Swift operators 138 ......................................................................................... Chapter 26: Method Swizzling 140 ............................................................................................................................ Section 26.1: Extending UIViewController and Swizzling viewDidLoad 140 ................................................................ Section 26.2: Basics of Swift Swizzling 141 .................................................................................................................... Section 26.3: Basics of Swizzling - Objective-C 141 ...................................................................................................... Chapter 27: Reflection 143 ........................................................................................................................................... Section 27.1: Basic Usage for Mirror 143 ........................................................................................................................ Section 27.2: Getting type and names of properties for a class without having to instantiate it 143 .................... Chapter 28: Access Control 147 ................................................................................................................................. Section 28.1: Basic Example using a Struct 147 ............................................................................................................. Section 28.2: Subclassing Example 148 ......................................................................................................................... Section 28.3: Getters and Setters Example 148 ............................................................................................................ Chapter 29: Closures 149 ............................................................................................................................................... Section 29.1: Closure basics 149 ...................................................................................................................................... Section 29.2: Syntax variations 150 ................................................................................................................................ Section 29.3: Passing closures into functions 150 ......................................................................................................... Section 29.4: Captures, strong/weak references, and retain cycles 152 ................................................................... Section 29.5: Using closures for asynchronous coding 153 ........................................................................................ Section 29.6: Closures and Type Alias 154 .................................................................................................................... Chapter 30: Initializers 155 ........................................................................................................................................... Section 30.1: Convenience init 155 .................................................................................................................................. Section 30.2: Setting default property values 157 ........................................................................................................ Section 30.3: Customizing initialization with parameters 158 ...................................................................................... Section 30.4: Throwable Initilizer 159 ............................................................................................................................. Chapter 31: Associated Objects 160 ......................................................................................................................... Section 31.1: Property, in a protocol extension, achieved using associated object 160 ............................................ Chapter 32: Concurrency 163 ...................................................................................................................................... Section 32.1: Obtaining a Grand Central Dispatch (GCD) queue 163 ......................................................................... Section 32.2: Concurrent Loops 163 ............................................................................................................................... Section 32.3: Running tasks in a Grand Central Dispatch (GCD) queue 164 ............................................................. Section 32.4: Running Tasks in an OperationQueue 166 ............................................................................................. Section 32.5: Creating High-Level Operations 167 ....................................................................................................... Chapter 33: Getting Started with Protocol Oriented Programming 169 .............................................. Section 33.1: Using protocols as first class types 169 ................................................................................................... Section 33.2: Leveraging Protocol Oriented Programming for Unit Testing 172 ...................................................... Chapter 34: Functional Programming in Swift 174 .......................................................................................... Section 34.1: Extracting a list of names from a list of Person(s) 174 .......................................................................... Section 34.2: Traversing 174 ........................................................................................................................................... Section 34.3: Filtering 174 ................................................................................................................................................ Section 34.4: Using Filter with Structs 175 ..................................................................................................................... Section 34.5: Projecting 176 ............................................................................................................................................ Chapter 35: Function as first class citizens in Swift 178 ................................................................................

Section 35.1: Assigning function to a variable 178 ........................................................................................................ Section 35.2: Passing function as an argument to another function, thus creating a Higher-Order Function 179 ............................................................................................................................................................................. Section 35.3: Function as return type from another function 179 .............................................................................. Chapter 36: Blocks 180 ................................................................................................................................................... Section 36.1: Non-escaping closure 180 ......................................................................................................................... Section 36.2: Escaping closure 180 ................................................................................................................................. Chapter 37: The Defer Statement 182 ................................................................................................................... Section 37.1: When to use a defer statement 182 ......................................................................................................... Section 37.2: When NOT to use a defer statement 182 ............................................................................................... Chapter 38: Style Conventions 183 .......................................................................................................................... Section 38.1: Fluent Usage 183 ........................................................................................................................................ Section 38.2: Clear Usage 184 ........................................................................................................................................ Section 38.3: Capitalization 185 ...................................................................................................................................... Chapter 39: NSRegularExpression in Swift 187 .................................................................................................. Section 39.1: Extending String to do simple pattern matching 187 ............................................................................. Section 39.2: Basic Usage 188 ........................................................................................................................................ Section 39.3: Replacing Substrings 188 .......................................................................................................................... Section 39.4: Special Characters 189 ............................................................................................................................. Section 39.5: Validation 189 ............................................................................................................................................ Section 39.6: NSRegularExpression for mail validation 189 ........................................................................................ Chapter 40: RxSwift 191 ................................................................................................................................................ Section 40.1: Disposing 191 ............................................................................................................................................. Section 40.2: RxSwift basics 191 ..................................................................................................................................... Section 40.3: Creating observables 192 ......................................................................................................................... Section 40.4: Bindings 193 ............................................................................................................................................... Section 40.5: RxCocoa and ControlEvents 193 ............................................................................................................. Chapter 41: Swift Package Manager 196 .............................................................................................................. Section 41.1: Creation and usage of a simple Swift package 196 ................................................................................ Chapter 42: Working with C and Objective-C 198 ............................................................................................ Section 42.1: Use a module map to import C headers 198 .......................................................................................... Section 42.2: Using Objective-C classes from Swift code 198 ..................................................................................... Section 42.3: Specify a bridging header to swiftc 200 .................................................................................................. Section 42.4: Use the C standard library 200 ................................................................................................................ Section 42.5: Fine-grained interoperation between Objective-C and Swift 200 ........................................................ Section 42.6: Using Swift classes from Objective-C code 201 ..................................................................................... Chapter 43: Documentation markup 203 ............................................................................................................. Section 43.1: Class documentation 203 .......................................................................................................................... Section 43.2: Documentation styles 203 ........................................................................................................................ Chapter 44: Typealias 207 ........................................................................................................................................... Section 44.1: typealias for closures with parameters 207 ............................................................................................ Section 44.2: typealias for empty closures 207 ............................................................................................................ Section 44.3: typealias for other types 207 ................................................................................................................... Chapter 45: Dependency Injection 208 .................................................................................................................. Section 45.1: Dependency Injection with View Controllers 208 .................................................................................... Section 45.2: Dependency Injection Types 211 ............................................................................................................. Chapter 46: Caching on disk space 214 ................................................................................................................. Section 46.1: Reading 214 ................................................................................................................................................ Section 46.2: Saving 214 ..................................................................................................................................................

Chapter 47: Algorithms with Swift 215 .................................................................................................................. Section 47.1: Sorting 215 .................................................................................................................................................. Section 47.2: Insertion Sort 218 ....................................................................................................................................... Section 47.3: Selection sort 218 ....................................................................................................................................... Section 47.4: Asymptotic analysis 219 ........................................................................................................................... Section 47.5: Quick Sort - O(n log n) complexity time 219 .......................................................................................... Section 47.6: Graph, Trie, Stack 220 ............................................................................................................................... Chapter 48: Swift Advance functions 234 ............................................................................................................ Section 48.1: Flatten multidimensional array 234 ......................................................................................................... Section 48.2: Introduction with advance functions 234 ................................................................................................ Chapter 49: Completion Handler 236 ..................................................................................................................... Section 49.1: Completion handler with no input argument 236 ................................................................................... Section 49.2: Completion handler with input argument 236 ........................................................................................ Chapter 50: Swift HTTP server by Kitura 238 ..................................................................................................... Section 50.1: Hello world application 238 ....................................................................................................................... Chapter 51: Generate UIImage of Initials from String 241 ........................................................................... Section 51.1: InitialsImageFactory 241 ............................................................................................................................ Chapter 52: Design Patterns - Creational 242 .................................................................................................... Section 52.1: Singleton 242 .............................................................................................................................................. Section 52.2: Builder Pattern 242 .................................................................................................................................... Section 52.3: Factory Method 248 .................................................................................................................................. Section 52.4: Observer 249 .............................................................................................................................................. Section 52.5: Chain of responsibility 250 ........................................................................................................................ Section 52.6: Iterator 252 ................................................................................................................................................. Chapter 53: Design Patterns - Structural 253 .................................................................................................... Section 53.1: Adapter 253 ................................................................................................................................................. Section 53.2: Facade 253 ................................................................................................................................................. Chapter 54: (Unsafe) Buer Pointers 255 ............................................................................................................ Section 54.1: UnsafeMutablePointer 255 ........................................................................................................................ Section 54.2: Practical Use-Case for Buer Pointers 256 ............................................................................................ Chapter 55: Cryptographic Hashing 257 ............................................................................................................... Section 55.1: HMAC with MD5, SHA1, SHA224, SHA256, SHA384, SHA512 (Swift 3) 257 ............................................. Section 55.2: MD2, MD4, MD5, SHA1, SHA224, SHA256, SHA384, SHA512 (Swift 3) 258 ............................................. Chapter 56: AES encryption 260 ................................................................................................................................ Section 56.1: AES encryption in CBC mode with a random IV (Swift 3.0) 260 ............................................................ Section 56.2: AES encryption in CBC mode with a random IV (Swift 2.3) 262 ........................................................... Section 56.3: AES encryption in ECB mode with PKCS7 padding 264 ......................................................................... Chapter 57: PBKDF2 Key Derivation 266 ............................................................................................................... Section 57.1: Password Based Key Derivation 2 (Swift 3) 266 ..................................................................................... Section 57.2: Password Based Key Derivation 2 (Swift 2.3) 267 ................................................................................. Section 57.3: Password Based Key Derivation Calibration (Swift 2.3) 268 ................................................................. Section 57.4: Password Based Key Derivation Calibration (Swift 3) 268 .................................................................... Chapter 58: Logging in Swift 270 .............................................................................................................................. Section 58.1: dump 270 .................................................................................................................................................... Section 58.2: Debug Print 271 ......................................................................................................................................... Section 58.3: print() vs dump() 272 ................................................................................................................................ Section 58.4: print vs NSLog 272 .................................................................................................................................... Chapter 59: Memory Management 274 .................................................................................................................

Section 59.1: Reference Cycles and Weak References 274 ......................................................................................... Section 59.2: Manual Memory Management 275 ......................................................................................................... Chapter 60: Performance 276 .................................................................................................................................... Section 60.1: Allocation Performance 276 ...................................................................................................................... Credits 278 ............................................................................................................................................................................ You may also like 282 ......................................................................................................................................................

GoalKicker.com – Swift™ Notes for Professionals 1 About Please feel free to share this PDF with anyone for free, latest version of this book can be downloaded from: https://goalkicker.com/SwiftBook This Swift™ Notes for Professionals book is compiled from Stack Overflow Documentation, the content is written by the beautiful people at Stack Overflow. Text content is released under Creative Commons BY-SA, see credits at the end of this book whom contributed to the various chapters. Images may be copyright of their respective owners unless otherwise specified This is an unofficial free book created for educational purposes and is not affiliated with official Swift™ group(s) or company(s) nor Stack Overflow. All trademarks and registered trademarks are the property of their respective company owners The information presented in this book is not guaranteed to be correct nor accurate, use at your own risk Please send feedback and corrections to web@petercv.com

GoalKicker.com – Swift™ Notes for Professionals 2 Chapter 1: Getting started with Swift Language Swift Version Xcode Version Release Date development began (first commit) - 2010-07-17 1.0 Xcode 6 2014-06-02 1.1 Xcode 6.1 2014-10-16 1.2 Xcode 6.3 2015-02-09 2.0 Xcode 7 2015-06-08 2.1 Xcode 7.1 2015-09-23 open-source debut - 2015-12-03 2.2 Xcode 7.3 2016-03-21 2.3 Xcode 8 2016-09-13 3.0 Xcode 8 2016-09-13 3.1 Xcode 8.3 2017-03-27 4.0 Xcode 9 2017-11-19 4.1 Xcode 9.3 2018-03-29 Section 1.1: Your first Swift program Write your code in a file named hello.swift: print("Hello, world!") To compile and run a script in one step, use swift from the terminal (in a directory where this file is located): To launch a terminal, press CTRL + ALT + T on Linux, or find it in Launchpad on macOS. To change directory, enter cddirectory_name (or cd .. to go back) $ swift hello.swift Hello, world! A compiler is a computer program (or a set of programs) that transforms source code written in a programming language (the source language) into another computer language (the target language), with the latter often having a binary form known as object code. (Wikipedia) To compile and run separately, use swiftc: $ swiftc hello.swift This will compile your code into hello file. To run it, enter ./, followed by a filename. $ ./hello Hello, world! Or use the swift REPL (Read-Eval-Print-Loop), by typing swift from the command line, then entering your code in the interpreter:

GoalKicker.com – Swift™ Notes for Professionals 3 Code: func greet(name: String, surname: String) { print("Greetings \(name) \(surname)") } let myName = "Homer" let mySurname = "Simpson" greet(name: myName, surname: mySurname) Let's break this large code into pieces: func greet(name: String, surname: String) { // function body } - create a function that takes a name and a surname. print("Greetings \(name) \(surname)") - This prints out to the console "Greetings ", then name, then surname. Basically \(variable_name) prints out that variable's value. let myName = "Homer" and let mySurname = "Simpson" - create constants (variables which value you can't change) using let with names: myName, mySurname and values: "Homer", "Simpson" respectively. greet(name: myName, surname: mySurname) - calls a function that we created earlier supplying the values of constants myName, mySurname. Running it using REPL: $ swift Welcome to Apple Swift. Type :help for assistance. 1> func greet(name: String, surname: String) { 2. print("Greetings \(name) \(surname)") 3. } 4> 5> let myName = "Homer" myName: String = "Homer" 6> let mySurname = "Simpson" mySurname: String = "Simpson" 7> greet(name: myName, surname: mySurname) Greetings Homer Simpson 8> ^D Press CTRL + D to quit from REPL. Section 1.2: Your first program in Swift on a Mac (using a Playground) From your Mac, download and install Xcode from the Mac App Store following this link. After the installation is complete, open Xcode and select Get started with a Playground:

GoalKicker.com – Swift™ Notes for Professionals 4 On the next panel, you can give your Playground a name or you can leave it MyPlayground and press Next: Select a location where to save the Playground and press Create:

GoalKicker.com – Swift™ Notes for Professionals 5 The Playground will open and your screen should look something like this:

GoalKicker.com – Swift™ Notes for Professionals 6 Now that the Playground is on the screen, press ⇧ + cmd + Y to show the Debug Area. Finally delete the text inside Playground and type: print("Hello world") You should see 'Hello world' in the Debug Area and "Hello world\n" in the right Sidebar:

GoalKicker.com – Swift™ Notes for Professionals 7 Congratulations! You've created your first program in Swift! Section 1.3: Your first program in Swift Playgrounds app on iPad Swift Playgrounds app is a great way to get started coding Swift on the go. To use it: 1- Download Swift Playgrounds for iPad from App Store.

GoalKicker.com – Swift™ Notes for Professionals 8 2- Open the app. 3- In the My Playgrounds tab, tap + on the top left corner and then select Blank template. 4- Enter your code. 5- Tap Run My Code to run your code. 6- At the front of each line, the result will be stored in a small square. Tap it to reveal the result. 7- To step slowly through code to trace it, tap the button next to Run My Code. Section 1.4: Installing Swift First, download the compiler and components. Next, add Swift to your path. On macOS, the default location for the downloadable toolchain is /Library/Developer/Toolchains. Run the following command in Terminal: export PATH=/Library/Developer/Toolchains/swift-latest.xctoolchain/usr/bin:"${PATH}" On Linux, you will need to install clang: $ sudo apt-get install clang If you installed the Swift toolchain to a directory other than the system root, you will need to run the following command, using the actual path of your Swift installation: $ export PATH=/path/to/Swift/usr/bin:"${PATH}" You can verify you have the current version of Swift by running this command: $ swift --version Section 1.5: Optional Value and Optional enum Optionals type, which handles the absence of a value. Optionals say either "there is a value, and it equals x" or "there isn't a value at all".

GoalKicker.com – Swift™ Notes for Professionals 9 An Optional is a type on its own, actually one of Swift’s new super-powered enums. It has two possible values, None and Some(T), where T is an associated value of the correct data type available in Swift. Let's have a look at this piece of code for example: let x: String? = "Hello World" if let y = x { print(y) } In fact if you add a print(x.dynamicType) statement in the code above you'll see this in the console: Optional<String> String? is actually syntactic sugar for Optional, and Optional is a type in its own right. Here's a simplified version of the header of Optional, which you can see by command-clicking on the word Optional in your code from Xcode: enum Optional<Wrapped> { /// The absence of a value. case none /// The presence of a value, stored as `Wrapped`. case some(Wrapped) } Optional is actually an enum, defined in relation to a generic type Wrapped. It has two cases: .none to represent the absence of a value, and .some to represent the presence of a value, which is stored as its associated value of type Wrapped. Let me go through it again: String? is not a String but an Optional<String>.The fact that Optional is a type means that it has its own methods, for example map and flatMap.

GoalKicker.com – Swift™ Notes for Professionals 10 Chapter 2: Variables & Properties Section 2.1: Creating a Variable Declare a new variable with var, followed by a name, type, and value: var num: Int = 10 Variables can have their values changed: num = 20 // num now equals 20 Unless they're defined with let: let num: Int = 10 // num cannot change Swift infers the type of variable, so you don't always have to declare variable type: let ten = 10 // num is an Int let pi = 3.14 // pi is a Double let floatPi: Float = 3.14 // floatPi is a Float Variable names aren't restricted to letters and numbers - they can also contain most other unicode characters, although there are some restrictions Constant and variable names cannot contain whitespace characters, mathematical symbols, arrows, private-use (or invalid) Unicode code points, or line- and box-drawing characters. Nor can they begin with a number Source developer.apple.com var π: Double = 3.14159 var : String = "Apples" Section 2.2: Property Observers Property observers respond to changes to a property's value. var myProperty = 5 { willSet { print("Will set to \(newValue). It was previously \(myProperty)") } didSet { print("Did set to \(myProperty). It was previously \(oldValue)") } } myProperty = 6 // prints: Will set to 6, It was previously 5 // prints: Did set to 6. It was previously 5 willSet is called before myProperty is set. The new value is available as newValue, and the old value is still available as myProperty.

GoalKicker.com – Swift™ Notes for Professionals 11 didSet is called after myProperty is set. The old value is available as oldValue, and the new value is now available as myProperty . Note: didSet and willSet will not be called in the following cases: Assigning an initial value Modifying the variable within its own didSet or willSet The parameter names for oldValue and newValue of didSet and willSet can also be declared to increase readability: var myFontSize = 10 { willSet(newFontSize) { print("Will set font to \(newFontSize), it was \(myFontSize)") } didSet(oldFontSize) { print("Did set font to \(myFontSize), it was \(oldFontSize)") } } Caution: While it is supported to declare setter parameter names, one should be cautious not to mix names up: willSet(oldValue) and didSet(newValue) are entirely legal, but will considerably confuse readers of your code. Section 2.3: Lazy Stored Properties Lazy stored properties have values that are not calculated until first accessed. This is useful for memory saving when the variable's calculation is computationally expensive. You declare a lazy property with lazy: lazy var veryExpensiveVariable = expensiveMethod() Often it is assigned to a return value of a closure: lazy var veryExpensiveString = { () -> String in var str = expensiveStrFetch() str.expensiveManipulation(integer: arc4random_uniform(5)) return str }() Lazy stored properties must be declared with var. Section 2.4: Property Basics Properties can be added to a class or struct (technically enums too, see "Computed Properties" example). These add values that associate with instances of classes/structs: class Dog { var name = "" } In the above case, instances of Dog have a property named name of type String. The property can be accessed and