For this series of posts I have used extensively the book Swift Apprentice by Ray Wenderlich.

I strongly suggest this book, because if you buy the digital copy, Ray Wenderlich guarantees updates for the rest of the life!

I have also to say that Ray Wenderlich offers a cheat sheet available for download for free.

The purpose of these post is not to copy the book itself, that I strongly suggest to read, also doing the suggested exercises, that give the required confidence to really learn the language.

In particular I will not explain how to use Xcode or the playgrounds. The idea is that you buy the book and read it!

Final note: my background is deep experience in C#, so maybe some concepts are obvious for me. If you read this article, find it useful, but would like that I add something, don't hesitate to comment here below! But remember, my goal is not to copy the book :-)

# Chapter 1: Expressions, Variables & Constants

## Code comments

Swift allows single line comments, multi line comments and also nested comments:

```
// This is a comment. It is not executed.
/* This is also a comment.
Over many..
many...
many lines. */
/* This is a comment.
/* And inside it
is
another comment.
*/
Back to the first.
*/
```

## Print in the debug area

```
print("Hello, Swift Apprentice reader!")
```

How to remove the new-line at the end, or how to finish the current line:

```
print("\(player), ", terminator: "") // no newline
print("") // print one final newline
```

## The remainder operation

Between ints:

```
28 % 10
```

Between decimal numbers:

```
(28.0).truncatingRemainder(dividingBy: 10.0)
```

## Some math functions

```
max(5, 10)
// 10
min(-5, -10)
// -10
sin(45 * Double.pi / 180)
// 0.7071067811865475
cos(135 * Double.pi / 180)
// -0.7071067811865475
(2.0).squareRoot()
// 1.414213562373095
Int.random(in: 1...6)
```

## Constants and variables

```
let number: Int = 10
var variableNumber: Int = 42
```

Variables are block-scoped.

# Chapter 2: Types & Operations

## Type conversion

```
var integer: Int = 100
var decimal: Double = 12.5
integer = Int(decimal)
```

## Type inference

In Xcode, you can analyze the type of a variable or constant with Option+Click on the name itself.

How to cast with type inference:

```
let actuallyDouble: Double = 3
let actuallyDouble = 3 as Double
```

## Characters and strings

```
let characterA: Character = "a"
let stringDog = "Dog" // Inferred to be of type String
```

Interpolation:

```
message = "Hello my name is \(name)!" // "Hello my name is Matt!"
```

Multi-line strings:

```
let bigString = """
You can have a string
that contains multiple
lines
by
doing this.
"""
print(bigString)
```

## Tuples

```
let coordinates: (Int, Int) = (2, 3)
let x1 = coordinates.0
let y1 = coordinates.1
```

Named tuples:

```
let coordinatesNamed = (x: 2, y: 3)
// Inferred to be of type (x: Int, y: Int)
let x2 = coordinatesNamed.x
let y2 = coordinatesNamed.y
```

Deconstruction:

```
let coordinates3D = (x: 2, y: 3, z: 1)
let (x3, y3, z3) = coordinates3D
let (x4, y4, _) = coordinates3D
```

## Type aliases

```
typealias Animal = String
let myPet: Animal = "Dog"
typealias Coordinates = (Int, Int)
let xy: Coordinates = (2, 4)
```

# Chapter 3: Basic Control Flow

## Bool toggling

```
var switchState = true
switchState.toggle() // switchState = false
switchState.toggle() // switchState = true
```

## If statement

```
let hourOfDay = 12
var timeOfDay = ""
if hourOfDay < 6 {
timeOfDay = "Early morning"
} else if hourOfDay < 12 {
timeOfDay = "Morning"
} else if hourOfDay < 17 {
timeOfDay = "Afternoon"
} else if hourOfDay < 20 {
timeOfDay = "Evening"
} else if hourOfDay < 24 {
timeOfDay = "Late evening"
} else {
timeOfDay = "INVALID HOUR!"
}
print(timeOfDay)
```

AND and OR conditions are short-circuited.

## While loops

```
var sum = 1
while sum < 1000 {
sum = sum + (sum + 1)
}
```

## Repeat While loops

```
sum = 1
repeat {
sum = sum + (sum + 1)
} while sum < 1000
```

# Chapter 4: Advanced Control Flow

## Ranges

```
let closedRange = 0...5
let halfOpenRange = 0..<5
```

## For loops

```
let count = 10
var sum = 0
for i in 1...count {
sum += i
}
```

Conditions in loops:

```
sum = 0
for i in 1...count where i % 2 == 1 {
sum += i
}
```

## Continue to an outer loop

```
sum = 0
rowLoop: for row in 0..<8 {
columnLoop: for column in 0..<8 {
if row == column {
continue rowLoop
}
sum += row * column
}
}
```

## Switch statements

```
switch hourOfDay {
case 0...5:
timeOfDay = "Early morning"
case 6...11:
timeOfDay = "Morning"
case 12...16:
timeOfDay = "Afternoon"
case 17...19:
timeOfDay = "Evening"
case 20..<24:
timeOfDay = "Late evening"
default: timeOfDay = "INVALID HOUR!"
}
```

Condition on cases:

```
switch number {
case let x where x % 2 == 0:
print("Even")
default:
print("Odd")
}
```

Pattern matching:

```
let coordinates = (x: 3, y: 2, z: 5)
switch coordinates {
case (0, 0, 0): // 1
print("Origin")
case (_, 0, 0): // 2
print("On the x-axis.")
case (0, _, 0): // 3
print("On the y-axis.")
case (0, 0, _): // 4
print("On the z-axis.")
default: // 5
print("Somewhere in space")
}
```

Pattern matching when capturing variables:

```
switch coordinates {
case (0, 0, 0):
print("Origin")
case (let x, 0, 0):
print("On the x-axis at x = \(x)")
case (0, let y, 0):
print("On the y-axis at y = \(y)")
case (0, 0, let z):
print("On the z-axis at z = \(z)")
case let (x, y, z):
print("Somewhere in space at x = \(x), y = \(y), z = \(z)")
}
```

More complex example:

```
switch coordinates {
case let (x, y, _) where y == x:
print("Along the y = x line.")
case let (x, y, _) where y == x * x:
print("Along the y = x^2 line.")
default:
break
}
```

# Chapter 5: Functions

## External names

Renaming an external name of a parameter:

```
func printMultipleOf(multiplier: Int, and value: Int) {
print("\(multiplier) * \(value) = \(multiplier * value)")
}
printMultipleOf(multiplier: 4, and: 2)
```

Hiding an external name of a parameter:

```
func printMultipleOf(_ multiplier: Int, and value: Int) {
print("\(multiplier) * \(value) = \(multiplier * value)")
}
printMultipleOf(4, and: 2)
```

Functions support default values.

## Return values

Return values:

```
func multiply(_ number: Int, by multiplier: Int) -> Int {
return number * multiplier
}
let result = multiply(4, by: 2)
```

Return value with a tuple:

```
func multiplyAndDivide(_ number: Int, by factor: Int)
-> (product: Int, quotient: Int) {
return (number * factor, number / factor)
}
let results = multiplyAndDivide(4, by: 2)
let product = results.product
let quotient = results.quotient
```

Removing the return value for single statement functions:

```
func multiply(_ number: Int, by multiplier: Int) -> Int {
number * multiplier
}
func multiplyAndDivide(_ number: Int, by factor: Int)
-> (product: Int, quotient: Int) {
(number * factor, number / factor)
}
```

## Variadic parameters

```
func getHighestGrade(for grades: Int...) -> Int {
grades.max() ?? 0
}
getHighestGrade() // 0
getHighestGrade(3, 7, 5) // 7
```

## Parameters passed by reference

```
func incrementAndPrint(_ value: inout Int) {
value += 1
print(value)
}
var count = 0
incrementAndPrint(&count)
```

## Overloading

```
func printMultipleOf(multiplier: Int, andValue: Int)
func printMultipleOf(multiplier: Int, and value: Int)
func printMultipleOf(_ multiplier: Int, and value: Int)
func printMultipleOf(_ multiplier: Int, _ value: Int)
```

## Functions as variables

Note that when passing a function as variable, the parameter names are not considered in the function signature.

```
func add(a: Int, b: Int) -> Int {
a + b
}
var function = add
function(4, 2)
```

Passing a function as a parameter to another function:

```
func printResult(_ function: (Int, Int) -> Int, _ a: Int, _ b: Int) {
let result = function(a, b)
print(result)
}
printResult(add, 4, 2)
```

## No return

```
func noReturn() -> Never {
}
```

## Commenting your functions

You can automatically comment a function in Xcode with Option-Command-/.

Sample of function declaration:

```
/// Calculates the average of three values
/// - Parameters:
/// - a: The first value.
/// - b: The second value.
/// - c: The third value.
/// - Returns: The average of the three values.
func calculateAverage(of a: Double, and b: Double, and c: Double) -> Double {
let total = a + b + c
let average = total / 3
return average
}
calculateAverage(of: 1, and: 3, and: 5)
```

## Closures

A closure is an anonymous method without parameter names.

A closure always require the return type, even if it is *Void*.

```
typealias Operate = (Int, Int) -> Int
let op: Operate = +
var addClosure: Operate = { (a: Int, b: Int) -> Int in
return a + b
}
```

Shortening closure syntax:

```
let longClosure = { (a: Int, b: Int) -> Int in
a * b
}
let noParameterTypes: Operate = { (a, b) -> Int in
a * b
}
let noReturnType: Operate = { (a, b) in
a * b
}
let shortClosure: Operate = { $0 * $1 }
```

Closures with Void return type:

```
let voidClosure: () -> Void = { () -> Void in
print("Test")
}
let voidClosure: () -> Void = {
print("Test")
}
```

# Chapter 6: Optionals

## Optionals

```
var errorCode: Int?
errorCode = 100
errorCode = nil
```

## Unwrapping

Force unwrapping:

```
var authorName: String? = "Matt Galloway"
var unwrappedAuthorName = authorName!
print("Author is \(unwrappedAuthorName)")
```

Optional binding (plus shadowing, because the unwrapped variable name is the same as the optional name):

```
if let authorName = authorName {
print("Author is \(authorName)")
} else {
print("No author.")
}
```

Multiple optional bindings (all the optionals must be not nil to enter the if statement):

```
if let authorName = authorName,
let authorAge = authorAge {
print("The author is \(authorName) who is \(authorAge) years old.")
} else {
print("No author or no age.")
}
```

Combine multiple unwrapping with additional boolean checks:

```
if let authorName = authorName,
let authorAge = authorAge,
authorAge >= 40 {
print("The author is \(authorName) who is \(authorAge) years old.")
} else {
print("No author or no age or age less than 40.")
}
```

## Introducing guard

Check of input parameters of functions (with guard, you have always to provide an else clause):

```
func guardMyCastle(name: String?) {
guard let castleName = name else {
print("No castle!")
return
}
// At this point, `castleName` is a non-optional String
print("Your castle called \(castleName) was guarded!")
}
```

Example of another use:

```
func maybePrintSides(shape: String) {
guard let sides = calculateNumberOfSides(shape: shape) else {
print("I don’t know the number of sides for \(shape).")
return
}
print("A \(shape) has \(sides) sides.")
}
```

## Nil coalescing

```
var optionalInt: Int? = 10
var mustHaveResult = optionalInt ?? 0
```