Appendix A: An Introduction to Swift

Until recently, writing an iPhone or iPad application meant working with Objective-C. Because of its unusual syntax, Objective-C is one of the most polarizing of programming languages—people tend to love it or hate it. At the World Wide Developer Conference in 2014, Apple changed all that by unveiling an alternative—a new language called Swift . Swift’s syntax is designed to be easily recognizable to programmers who are used to some of the more popular object-oriented programming languages like C++ and Java, therefore making it easier for them to start writing applications for iOS (and for Macs since Swift is also fully supported as a development language on macOS). This appendix covers the parts of Swift that you’ll need to know in order to understand the example code in this book. I assume that you already have some programming experience and that you know what variables, functions, methods, and classes are. This appendix is neither a reference nor an exhaustive guide to the language—for that, there are numerous other resources, some of which are listed in Chapter 1 .

Swift Basics

One of the most useful new features introduced in Xcode 6 alongside Swift is the playground . As the name suggests, a playground is a place where you can go to play with code without having to create an environment in which to run it—just open a playground, type in some code, and see the results. Playgrounds are a great place to prototype something new, and they are also an ideal place to start learning a new language, so you’re going to use them throughout this appendix.

Let’s begin by creating a new playground. Start Xcode and go to File ➤ New ➤ Playground. In the dialog that opens, choose an iOS playground of Blank type (Figure A-1 ). Then choose a name for your playground (something like SwiftBasics) and make sure that Platform is iOS. Then press Next. Choose the folder in which your playground will be saved and then click Create. Xcode creates the playground and opens it in a new window, as shown in Figure A-2 . As you read through the examples in this appendix, feel free to experiment by adding code of your own to the playground or by modifying the examples to see what happens.

A329781_4_En_BookBackmatter_Fig1_HTML.jpg
Figure A-1. Choose a Blank iOS playground
A329781_4_En_BookBackmatter_Fig2_HTML.jpg
Figure A-2. The newly created playground

Playgrounds, Comments, Variables, and Constants

Let’s take a moment to look at what you’ve got in your playground . It’s divided into two areas—code is on the left, and results appear on the right. As you type code, the Swift compiler compiles and executes it and shows you the result almost immediately. The code in Figure A-1 declares a new variable called str and initializes it with the string "Hello, playground" . You can see this string in the results column on the right. Try changing the value and notice that the result updates to match as soon as you stop typing.

The code on line 1 in Figure A-1 is a comment. Anything following the character sequence // up to the end of the line is ignored by the compiler. Here, the comment occupies the whole line, but that’s not the only option. You could add a comment to the end of a line of code too:

var str = "Hello, playground"   // my comment for this line

To write a comment that’s longer than one line, start it with /* and end it with */ , like this:

/*
 This is a comment that occupies
 More than one line.
 */

There are various different ways to write a multiline comment. Some people like to make it clear that a line is part of a comment by starting each line with a * character.

/*
 * This is a comment that occupies
 * More than one line.
 */

Other people like to write single-line comments like this:

/* This is another way to write a single-line comment. */

The import statement on line 3 of Figure A-1 makes Apple’s UIKit framework available for use in the playground.

import UIKit

IOS includes many frameworks, some of which you’ll read about in this book. UIKit is the user interface framework, which you’ll be using in all of your code examples. Another framework that you’ll frequently make use of is Foundation, which contains classes that provide basic functionality like date and time handling, collections, file management, networking, and much more. To get access to this framework, you need to import it, like this:

import Foundation

However, UIKit automatically imports Foundation, so any playground that imports UIKit gets access to Foundation for free, without having to add an explicit import for it.

Line 5 is the first (and only) line of executable code in this playground.

var str = "Hello, playground"

The var keyword declares a new variable with a given name. Here, the variable is called str , which is appropriate because it’s a string. Swift is very liberal with variable names: you can use almost any character you like in the name, with the exception of the first character , which is somewhat restricted. You can find the precise rules in Apple’s documentation at https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language .

Following the declaration of the variable comes an expression that assigns its initial value. You don’t have to initialize a variable when you declare it, but you must do so before you use it (i.e., before you execute any code that reads its value). However, if you choose to assign a value, then Swift can infer the variable’s type, saving you the trouble of stating it explicitly. In this example, Swift infers that str is a string variable because it was initialized with a string literal. If you choose not to provide an initializer (perhaps because there is no fixed initial value), you must declare the variable’s type by appending it to the name and separated from it by a colon, like this:

var str2: String            // an uninitialized variable

Try changing the code on line 5 of the playground to this:

var str: String
str = "Hello, playground"

This is completely equivalent to the original code, but now you’ve had to explicitly state that str is a string variable ( String is the Swift type that represents a string). In most cases, it’s easier to combine the declaration and initialization and allow the compiler to infer the variable’s type.

Here’s another example that makes use of Swift’s type inference feature :

var count = 2

Here, the compiler infers that the count variable is an integer. Its actual type is Int (you’ll cover the numeric types that Swift provides in the next section). How can you be sure that this is the case? Easy. Let Swift tell you. Type the preceding code into the playground, hover the mouse over count , and hold down the ⌥ (Option) key. The cursor changes to a question mark. Now click the mouse and Swift shows you the type that it’s inferred for the variable in a pop-up, as shown in Figure A-3 .

A329781_4_En_BookBackmatter_Fig3_HTML.jpg
Figure A-3. Getting the inferred type of a variable

The fact that you haven’t explicitly declared the type of a variable doesn’t mean that it doesn’t have one or that you can play fast and loose with it. Swift assigns a type when the variable is declared, and then you have to stick with that type. Unlike dynamic languages like JavaScript, you can’t change the type of a variable simply by assigning a new value to it. Try doing this:

var count = 2
count = "Two"

Attempting to assign a string value to an integer variable is an error; you’ll see a red marker in the margin on the left of the playground. Click it, and Swift displays a message explaining the problem (see Figure A-4 ).

A329781_4_En_BookBackmatter_Fig4_HTML.jpg
Figure A-4. Swift is not a dynamic language. You can’t change the type of a variable.

If you’ve programmed before, you may notice that you aren’t bothering to add semicolons at the end of your statements. That’s one of the many nice little features of Swift: it’s almost never necessary to end a statement with a semicolon. If you’re used to writing in C, C++, Objective-C, or Java , that will probably feel a bit strange at first, but after a while, you’ll get used to it. Of course, you can type the semicolon if you want, but most likely you’ll wind up not doing so. The only time you must use a semicolon is if you want to write two statements on the same line. This code is not valid:

var count = 2 count = 3

Add a semicolon, and the compiler is happy again.

var count = 2; count = 3

As the preceding line of code shows, you can change the value of a variable. That’s why it’s called a variable , after all. What if you just want to give a name to a fixed value? In other words, you want to create a constant and give it a name. For that, Swift provides the let statement, which is just like var , except that you must provide an initial value.

let pi = 3.14159265

As with variables, Swift can infer the type of the constant (or you can explicitly state it if you want), but you can’t reassign the value of a constant, which is, of course, the point of making it constant.

pi = 42       // Error - Cannot assign to value: 'pi' is a 'let' constant

Naturally, you can initialize the value of a variable from a constant.

let pi = 3.14159265
var value = pi

As you’ve seen, Swift prints the results of executable statements to the right of the corresponding code. You can also create output using the print() function from the Swift standard library. For example, try this:

print("Hello, world")

The string "Hello, world" followed by a newline character appears in the playground output area, as usual, but you can also make it appear inline with the code. To do that, hover the mouse over the results area, and you’ll see a couple of circular controls appear. Click the control on the right, and the result appears right below the print() statement, as shown in Figure A-5 . Also notice at the bottom is the debug area where the output also appears. You can open or close the debug area using the triangle disclosure button to the left of the bottom of the playground.

A329781_4_En_BookBackmatter_Fig5_HTML.jpg
Figure A-5. Viewing output inline with the code and in the debug area

If you don’t want the newline to be automatically appended to the string, you can get rid of it or replace it with another string by using a slightly different version of print() that takes an additional argument . Try this:

print("Hello, world", terminator: "")

This code replaces the newline with an empty string, and if you check in the results area, you’ll see that the newline is no longer there.

Tip

print() is a function from the Swift standard library. You’ll find documentation for the library at https://developer.apple.com/library/ios/documentation/General/Reference/SwiftStandardLibraryReference . Another way to see what’s in the standard library is to add the line import Swift to your playground and then hold down the ⌘ (Cmd) key and click the word Swift . The playground switches to a listing of the content of the standard library. There’s a lot of information here, and you’ll need to know a lot more about Swift to understand all of it, but it’s worth looking it over to get a feel for what’s available.

Predefined Types, Operators, and Control Statements

Swift comes with a set of basic, predefined types . In later sections, you’ll see that you can add to these by defining your own classes, structures, and enumerations. You can even add functionality to an existing type by creating an extension of that type. Swift also has operators and control statements that will no doubt be familiar to you from other languages. Let’s start with a quick overview of the basic types.

Numeric Types

Swift has four basic numeric types Int , Uint , Float , and Double —and a collection of more specialized integer types. The full set of integer types, together with their sizes (in bits) and the ranges of values that they can represent, is listed in Table A-1 .

Table A-1. Integer Types

Type

Size in Bits

Maximum Value

Minimum Value

Int

32 or 64

As Int32 or Int64

As Int32 or Int64

UInt

32 or 64

As UInt32 or UInt64

0

Int64

64

9,223,372,036,854,775,807

–9,223,372,036,854,775,808

UInt64

64

18,446,744,073,709,551,615

0

Int32

32

2,147,483,647

–2,147,483,648

UInt32

32

4,294,967,295

0

Int16

16

32767

–32768

Uint16

16

65535

0

Int8

8

127

–128

UInt8

8

255

0

Int and its derivatives are signed values, whereas the types related to UInt are unsigned. The default type for integer values (i.e., the type that’s inferred when you write something like var count = 3 ) is Int and is the recommended type to use, unless you have a specific reason to use one of the others.

As you can see from the table, the range of values that Int and UInt can represent depends on the platform. On 32-bit systems (e.g., some iPads and all iPhones before the iPhone 4s, and the iPhone 5c), these are both 32-bit values, whereas on 64-bit systems, they are 64 bits wide. If you need a value that’s definitely 32-bit or definitely 64-bit, then use Int32 or Int64 instead. The Int8 and UInt8 types can be used to represent bytes.

You can discover the maximum and minimum values for each of these types programmatically by using their max and min properties. For example, try entering these lines into your playground (without the comments, which show the results):

print(Int8.max)       // 127
print(Int8.min)       //  -128
print(Int32.max)      // 2,147,483,647
print(Int32.min )     // -2,147,483,648
print(UInt32.max)     // 4,294,967,295

Integer literals can be written in decimal, hexadecimal, binary, or octal number bases. Try out these examples:

let decimal = 123         // Value is 123
let octal = 0o77          // Octal 77 = decimal 63
let hex = 0x1234          // Hex 1234 = decimal 4660
let binary = 0b1010       // Binary 1010 = decimal 10

The prefix 0o indicates octal, 0x indicates hexadecimal, and 0b indicates binary. For readability, you can also use an underscore character ( _ ) anywhere to separate number groups .

let v = -1_234       // Same as -1234
let w = 12_34_56     // Same as 123456

Notice that you don’t have to stick with the normal rule of grouping by units of three digits.

The Float and Double types are respectively 32-bit and 64-bit floating-point numbers. You assign a value to a floating-point variable by using a floating-point literal. Swift infers a type of Double , unless otherwise specified.

let a = 1.23             // This is inferred to be a Double
let b: Float = 1.23      // Forced to be Float

You can also use exponential (or scientific) notation, which is convenient for large numbers.

let c = 1.23e2         // Evaluated as 123.0
let d = 1.23e-1        // Evaluated as 0.123
let e = 1.23E-1        // Same as 1.23e-1

By their nature, floating-point numbers are not completely precise. One reason for this is that fractional values cannot be accurately represented in binary floating-point form. You can see this if you enter the following into the playground (where, as before, the comment shows the result):

let f: Float = 0.123456789123        // 0.1234568
let g: Double = 0.123456789123       // 0.123456789123

You can see that the Float representation of this value is less accurate than the Double representation. If you make the fractional part longer, you’ll exceed the precision of the Double format as well.

let g: Double = 0.12345678912345678  // 0.1234567891234568

Floating-point numbers also lose precision when their value is large.

let f: Float = 123456789123456        // Inaccurate: 1.234568e+14
let g: Double = 123456789123456       // Accurate: 123,456,789,123,456.0
let h: Double = 123456789123456789    // Inaccurate: 1.234567891234568e+17

Unlike other languages , Swift does not provide implicit type conversion when you assign a variable (or expression) of one numeric type to a variable of another numeric type. For example, this code does not compile, as shown in Figure A-6 :

A329781_4_En_BookBackmatter_Fig6_HTML.jpg
Figure A-6. Swift does not allow you to combine variables of different types
let a = 123
let b = 0.456
let c = a + b

Variable a is of type Int , and b is a Double . Swift could convert the Int to a Double and perform the addition, but it does not. You have to perform the conversion yourself.

let a = 123
let b = 0.456
let c = Double(a) + b

The expression Double(a) invokes an initializer of the Double type with an integer argument. The numeric types all provide initializers that let you perform conversions of this kind.

Another example that arises frequently involves the CGFloat type. CGFloat is a floating-point type defined by the Core Graphics framework. It’s used to represent coordinates and sizes, among other things. Depending on whether your application is running on a 32-bit or 64-bit platform, it’s equivalent to either Float or Double . To perform operations that involve a mix of CGFloat s and other types, you need to explicitly convert one to the other. For example, the following code adds a Double and a CGFloat , producing a CGFloat result by converting the Double to CGFloat :

let a: CGFloat = 123
let b: Double = 456
let c = Double(a) + b    // Result is of type Double

On 32-bit platforms, CGFloat is less precise than Double , so this operation may lose information, but that’s inevitable if you need a value of type CGFloat . If you need a result of type Double , you can convert the CGFloat to Double without losing accuracy.

It’s important to note that Swift allows you to mix numeric types when all of the values concerned are literals. Here’s an example:

1 + 0.5      // Evaluated as 1.5

You’ll find all of the usual binary arithmetic operators in Swift. You can use them to combine numbers of the same type, and you can apply them to numbers of different types if you explicitly convert one of the operands, as you have just seen. Table A-2 lists the arithmetic operators that are available. Operators are listed in decreasing order of precedence .

Table A-2. Predefined Binary Arithmetic Operators

Operator

Meaning

<<

Bitwise left shift

>>

Bitwise right shift

* , &*

Multiplication

/ , &/

Division

% , &%

Remainder

&

Bitwise AND

+ , &+

Addition

- , &-

Subtraction

|

Bitwise OR

^

Bitwise XOR

The arithmetic operations + , - , * , / , and % detect overflow. If you want overflow to be ignored, use &+ , &- , &* , &/ , or &% instead. For example, enter this code into the playground :

let a = Int.max
let b = 1
let c = Int.max + b

You’re adding 1 to the largest representable integer value, which will trigger overflow. In the playground, you’ll see an error message for the line containing the assignment to the variable c , but if you execute this same code in an application, it would crash. To allow the operation to proceed ignoring the overflow, use &+ instead.

let a = Int.max
let b = 1
let c = a &+ b

The << and >> operators perform a left and right shift of the left operand by the amount specified by their right operand. This is equivalent to multiplication and division by a power of two. Here’s an example:

let a = 4
let b = a << 2   // Result is 16
let c = b >> 1   // Result is 8

When the left operand is negative, the sign of the result is preserved.

let a = -4
let b = a << 2   // Result is -16
let c = b >> 1   // Result is -8

The & , | , and ^ operations perform bitwise AND, OR, and XOR operations on their operands. This is not to be confused with the operators && and || , which are logical operators that give a Boolean result (see the “Booleans” section later in this appendix). Here are some examples:

let a = 7          // Value 0b111
let b = 3          // Value 0b011
let c = a & b      // Result is 0b011 = 3


let a = 7          // Value 0b111
let b = 3          // Value 0b011
let c = a | b      // Result is 0b111 = 7


let a = 7          // Value 0b111
let b = 3          // Value 0b011
let c = a ^ b      // Result is 0b100 = 4

There are also compound variants of these operators that perform the operation followed by an assignment, with the target of the assignment acting as the left operand of the operation. Here’s an example:

var a = 10
a += 20       // Shorthand for a = a + 20, result = 30


var b = 7
b &= 3        // Shorthand for b = b & 3, result = 3
Note

Starting in Swift 3, the unary operators ++ and -- are no longer available. You’ll need to use a format to replace something like a++ with a += 1 . This also means you’ll need to be aware, when converting code with these unary types, of the order of the operator (i.e., ++a vs. a++ and so on).

The unary operator performs bitwise inversion of the bits of its integer operand .

let a = 0b1001
let b = ∼a

The result of this operation in 32 bits is 0b11111111111111111111111111110110 , which is the same as –10.

Strings

A string , represented by the String type, is a sequence of Unicode characters. The fact that Swift uses Unicode in strings makes it possible to build applications that support many different character sets without requiring special code. However, it has some complications, some of which are mentioned here. For a full discussion on the implications of the use of Unicode, refer to The Swift Programming Language , which you’ll find on Apple’s Developer web site at the URL shown earlier, or in iBooks.

A string literal is a sequence of characters enclosed in double quotes, like this example that you’ve already seen:

let str = "Hello, playground"

If you need to include a " character in a string, escape it with a character, like this:

let quoted = "Contains "quotes""      // Contains "quotes"

To get a , escape it with another , like this:

let backslash = "\"     // Result is 

Any Unicode character can be embedded in a string by giving its hexadecimal representation (or code point ), surrounded by u{} . For example, the @ symbol has code point 0x40, so the following example shows two ways to represent @ in a Swift string:

let atSigns = "@u{40}"     // Result is @@

Certain characters have special escape representations. For example, and represent the new line and tab characters, respectively.

let specialChars = "Line1
Line2	Tabbed"

Strings have the useful ability to interpolate expressions enclosed in the escape sequence () . Here’s an example:

print("The value of pi is (Double.pi)")   // Prints "The value of pi is 3.14159265358979
"

This code interpolates the value of the predefined constant .pi into the string and then prints the result. The interpolated value can also be an expression, and there can be more than one of them.

// This code prints: "Area of a circle of radius 3.0 is 28.2743338823081
"
let r = 3.0
print("Area of a circle of radius (r) is (Double.pi * r * r)")

The + operator can be used to concatenate strings . This is the only way to combine strings that you want to split over more than one line of a source code file.

let s = "That's one small step for man, " +
        "one giant leap for mankind"
print(s)   // "That's one small step for man, one giant leap for mankind "

You can compare two strings using the == and != operators (see the “Booleans” section), which effectively perform a character-by-character comparison of their operands. Here’s an example:

let s1 = "String one"
let s2 = "String two"
let s3 = "String " + "one"
s1 == s2     // false: strings are not the same
s1 != s2     // true: strings are different
s1 == s3     // true: strings contain the same characters.

The seemingly simple task of getting the length of a string is complicated by the fact that strings are composed of Unicode characters because not every Unicode character is represented by a single code point. You’re going to skip a detailed discussion of this subject here, but there are two things to be aware of. First, if you want to get an accurate count of the number of characters in a string, which works under all circumstances, use the string’s characters property and then get its length.

s3.characters.count    // 10

If you know that the string only contains characters that are represented by a single Unicode code point, you can use get a count of a UTF-16 view of the string instead, which may be faster under some circumstances.

s3.utf16.count      // 10

The String type itself provides quite a few useful string operations, which you’ll find documented in the Swift library reference cited earlier in this appendix. You can also make use of the fact that Swift automatically bridges the String type to the NSString class in the Foundation framework, which means that methods defined by NSString can be used as if they were also defined on String itself.

The Character type can be used to hold a single character from a string. This allows iteration over the individual characters of a string via its characters property.

let s = "Hello"
for c in s.characters {
    print(c)
}

The body of the for loop in this example (the syntax of which is discussed later) is executed once for each character in the string, with the character assigned to the variable c , which is inferred to be of type Character . In the playground, you can’t directly see the result of this loop in the results column—only that it was executed five times. Instead, click the leftmost of the two controls that appear when you hover over the result in the results column (the one that looks like an eye) to get a pop-up and then right-click the pop-up and select Value History from the menu that appears to see all of the characters, as shown in Figure A-7 .

A329781_4_En_BookBackmatter_Fig7_HTML.jpg
Figure A-7. Value History pop-up
Tip

If you don’t see the results column, hover the mouse over the right edge until you see the column-width drag bar and then use it to widen the width of the results panel.

You can create and initialize a Character in the same way as a String , but you need to explicitly state the type to avoid the inference of String , and the initializer must consist of exactly one character:

let c: Character = "s"

There’s not much you can do with Character s other than compare them with other Character s. You can’t append them to each other, and you can’t directly add them to String s. You have to use the append() method of String instead.

let c: Character = "s"
var s = "Book"  // "var" because we want to modify it
s += c          // Error - illegal
s.append(c)     // "Books" - Legal

Strings in Swift are not immutable, but they are value objects , which means that whenever you assign a string to a variable or use one as a function argument or return value, the string is copied. Modifications made to the copy do not affect the original.

var s1 = "Book"
var s2 = s1             // s2 is now a copy of s1
s2 += "s"               // Appends to s2; s1 is unchanged
s1                      // "Book"
s2                      // "Books"
Note

For the sake of efficiency, the actual copy of a string’s content does not happen immediately upon assignment. In the preceding example, the strings s1 and s2 share the same copy of their character content after the assignment s1 = s2 , until the statement s2 += "s" is executed. At this point, a copy of the shared content is made and installed in s2 before the character "s" is appended to it. All of this happens automatically.

Booleans

Booleans are represented by the Bool type, with possible values of true or false .

var b = true              // Inferred type is Bool
var b1: Bool
b1 = false

Swift has the usual set of comparison operators ( == , != , > , < , >= , <= ) that return a Bool value when applied to numeric values.

var a = 100
var b = 200
var c = a


a == c      // true
a == b      // false
a != b      // true
a > b       // false
a < b       // true
a >= c      // true

Incidentally, these operators can also be applied to strings .

let a = "AB"
let b = "C"
let c = "CA"
let d = "AB"
a == b     // false - strings have different content
a == d     // true - strings have the same content
a != c     // true - strings have different content
a > b      // false: uses sorting order
a < c      // true: both start with C, but string c is longer than a

You can negate a Boolean value with the unary ! operator.

var a = 100
var b = 200
a == b           // false
!(a == b)        // !false == true

Boolean expressions can be combined using the == , != , && , and || operators. The && and || operators are short-circuiting, which means they evaluate their second operand only if the result is not determined by the value of the first operand. Specifically, the second operand of a || operator does not need to be evaluated if the first is true , and the second operand of && is not evaluated if the first is false .

var a = 100
var b = 200
var c = 300


a < b && c > b   // true; both expression are evaluated
a < b || c > b   //  true: second expression is not evaluated
a > b && c > b   // false: second expression is not evaluated
Enumerations

Enumerations let you give meaningful names to the values of types where that set of values is fixed and known in advance. To define an enumeration, you give it a name and list all of the possible values as cases.

enum DaysOfWeek {
    case Sunday, Monday, Tuesday, Wednesday,
         Thursday, Friday, Saturday
}

You can also define each case separately.

enum DaysOfWeek {
    case Sunday
    case Monday
    case Tuesday
    case Wednesday
    case Thursday
    case Friday
    case Saturday
}

To refer to an enumeration value, use the enumeration name and the case name, separated by a period .

var day = DaysOfWeek.Sunday     // "day" is inferred to be of type "DaysOfWeek"

When the context is clear, you can omit the enumeration name. In the following example, the compiler already knows that the variable day is of type DaysOfWeek , so there is no need to explicitly say so when assigning to it.

day = .Friday      // Note that the "." Is required

In Swift, you can also give an associated value to an enumeration case. Try this example in your playground.

enum Status {
    case OK
    case ERROR(String)
}


let status = Status.OK
let failed = Status.ERROR("That does not compute")

Here, the ERROR case has an associated value—a string that describes the error. You can recover the associated value in a switch statement, as you’ll see in upcoming “Control Statements” section .

In some cases, it is useful to map each enumeration case to a value, referred to as a raw value . To do this, specify the type of the value along with the enumeration name and then assign individual values to each case as it is defined. Here’s a variant of the DaysOfWeek enum that assigns an integer value to each case:

enum DaysOfWeek : Int {
    case Sunday = 0
    case Monday
    case Tuesday
    case Wednesday
    case Thursday
    case Friday
    case Saturday
}

Raw values can be strings or any of the numeric types. When the raw value type is an integer, you don’t need to assign an explicit value to each case; unassigned values are inferred by adding 1 to the previous raw value. In the preceding example, Sunday was assigned the raw value 0, and as a result, Monday is automatically given the raw value 1, Tuesday is assigned the raw value 2, and so on. You can override the automatic assignment of values, as long as each case has a unique value.

enum DaysOfWeek : Int {
    case Sunday = 0
    case Monday          // 1
    case Tuesday         // 2
    case Wednesday       // 3
    case Thursday        // 4
    case Friday = 20     // 20
    case Saturday        // 21
}

You can get the raw value for a case by accessing its rawValue property .

var day = DaysOfWeek.Saturday
let rawValue = day.rawValue           // 21. DaysOfWeek.Saturday.rawValue is also valid

Here’s another example, using String as the raw value type.

enum ResultType : String {
    case SUCCESS = "Success"
    case WARNING = "Warning"
    case ERROR = "Error"
}
let s = ResultType.WARNING.rawValue    // s = "Warning"

Given a raw value, you can construct the corresponding case value by passing it to an initializer.

let result = ResultType(rawValue: "Error")

In this example, the type of the result variable is not ResultType , but ResultType? , an example of an optional . Since it’s possible to pass an invalid raw value to the initializer, there has to be some way to indicate that there is no valid case with that value. Swift does this by returning the special value nil ; but nil cannot be assigned to an ordinary variable, only to an optional. Optional types are indicated by a trailing ? , and you need to be careful when manipulating them. I will discuss optionals in more detail later.

Arrays, Ranges, and Dictionaries

Swift provides three basic collection types (arrays, dictionaries, and sets) and a range syntax that provides a convenient way to represent a (possibly large) range of values. Ranges are particularly useful when accessing arrays.

Arrays and Ranges

Swift supports the creation of an array of values using the syntax [type] , where type is the type of the array value. The following code creates and initializes an array of integers and an array of strings:

var integers = [1, 2, 3]
var days = ["Sunday", "Monday", "Tuesday", "Wednesday",
                   "Thursday", "Friday", "Saturday"]

You can, of course, separate the declaration and initialization of an array, as long as it’s initialized before it is used. This requires explicit specification of the array type .

var integers: [Int]        // [Int] means "ar
ray of Ints"
integers = [1, 2, 3]

Use [] to initialize an empty array.

var empty: [String] = []

To access the elements of an array, use a numeric subscript as an index. The first element of the array has index 0.

integers[0]        // 1
integers[2]        // 3
days[3]            // "Wednesday"

Use the same syntax to assign a new value to an element of the array.

integers[0] = 4               // [4, 2, 3]
days[3] = "WEDNESDAY"         // Replaces "Wednesday" with "WEDNESDAY"

To extract or modify part of an array, use the Swift range syntax . This can result in a change in the number of elements in the array .

var integers = [1, 2, 3]
integers[1..<3]               // Get elements 1 and 2 as an array. Result is [2, 3]
integers[1..<3] = [4]         // Replace elements 1 and 2 with [4]. Result is [1, 4]


integers = [1, 2, 3]
integers[0...1] = [5, 4]     // Replace elements 0 and 1 with [5, 4]. Result is [5, 4, 3]
Note

If you view this in the results column, you won’t see the correct answer; you’ll need to expand the result as I showed earlier or view it in the debug panel at the bottom.

The range syntax a..<b means all the values from a to b , excluding b ; so 1..<5 is the same as 1, 2, 3, 4. The syntax a...b (note that there are three consecutive periods ) includes b in the range so that 1...5 means 1, 2, 3, 4, 5. The range a..<a is always empty, whereas the range a...a contains exactly one element ( a itself). The value of b must be greater than or equal to the value of a , and there is an implicit increment of 1.

To get the number of elements in an array, use its count property.

var integers = [1, 2, 3]
integers.count                   // 3
integers[1..<3] = [4]
integers.count                   // 2

To add an element to an array, use the append() method or the insert(_:atIndex:) method .

var integers = [1, 2, 3]
integers.append(4)                // Result is [1, 2, 3, 4]
integers.insert(-1, atIndex: 0)   // Result is [-1, 1, 2, 3, 4]

You can also use the + operator to concatenate two arrays and the += operator to add one array to another.

var integers = [1, 2, 3]
let a = integers + [4, 5]  // a = [1, 2, 3, 4, 5]; integers array unchanged
integers += [4, 5]         // Now integers = [1, 2, 3, 4, 5]

Use the remove() , removeSubrange() , and removeAll() methods to remove all or some of the elements of an array.

var days = ["Sunday", "Monday", "Tuesday", "Wednesday",
            "Thursday", "Friday", "Saturday"]


days.remove(at: 3)                       // Removes "Wednesday" and returns it to the caller
days.removeSubrange(0..<4)               // Leaves ["Friday", "Saturday"]
days.removeAll(keepingCapacity: false)   // Leaves an empty array

The keepingCapacity argument passed to removeAll() indicates whether the space allocated for the array’s elements should be kept (value true ) or released (value false ).

You can iterate over a whole array or over a part of an array using the for statement, which is discussed in the “Control Statements” section.

If an array is created using a let statement, neither it nor its contents can be modified in any way.

let integers = [1, 2, 3]                    // Constant array
integers = [4, 5, 6]                        // Error: cannot replace the array
integers[0] = 2                             // Error: cannot reassign elements
integers.removeAll(keepingCapacity: false)  // Error: cannot modify content

Like strings, arrays are value objects, so assigning them or passing them to or from functions creates a copy.

var integers = [1, 2, 3]
var integersCopy = integers   // Creates a copy of "integers"
integersCopy[0] = 4           // Does not change "integers"
integers                      // [1, 2, 3]
integersCopy                  // [4, 2, 3]

You can use the contains() method to find out whether an array contains a given element.

let integers = [1, 2, 3]
integers.contains(2)     // true
integers.contains(4)     // false

To get the index of an element in an array, use the index(of: ) method .

let integers = [1, 2, 3]
integers.index(of: 3)        // Result is 2

If the element is not found in the array, the result is nil .

let integers = [1, 2, 3]
integers.index(of: 5)        // Result is nil
Dictionaries

You can create a dictionary , a data structure mapping instances of a key to a corresponding value, using a syntax that is similar to that used for an array. You’ll sometimes see dictionaries referred to as maps . The following code creates a dictionary in which the keys are strings and the values are integers:

var dict = ["Red": 0,
            "Green": 1,
            "Blue": 2]

The formal type of this dictionary is [String: Int] . You may also see this referred to as Dictionary<String, Int> , using generics syntax, which I’m not going to cover in this appendix. Similarly, you may see an array of type [Int] referred to as Array<Int> .

If you don’t use an initializer, you need to explicitly state the type of the dictionary when you declare it.

var dict: [String: Int]
dict = ["Red": 0, "Green": 1,  "Blue": 2]

To get the value of a dictionary entry given its key, use subscript notation , like this:

let value = dict["Red"]  // Result is 0, the value mapped to the key "Red"

You can modify a dictionary in much the same way as you modify an array.

dict["Yellow"] = 3    // Adds a new value with key Yellow
dict["Red"] = 4       // Updates the value with key Red

To remove an element from the dictionary, use the removeValue(forKey: ) method; to remove all values, use removeAll() .

var dict = ["Red": 0, "Green": 1,  "Blue": 2]
dict.removeValue(forKey: "Red")   // Removes value with key "Red"
dict.removeAll()                  // Empties the dictionary

Dictionaries created using the let statement cannot be modified.

let fixedDict = ["Red": 0,  "Green": 1, "Blue": 2]
fixedDict["Yellow"] = 3              // Illegal
fixedDict["Red"] = 4                 // Illegal
fixedDict = ["Blue", 7]              // Illegal
fixedDict.removeValue(forKey:"Red")  // Illegal

You can iterate over the keys of a dictionary using the for statement, as you’ll see in the “Control Statements” section. To get the number of key-value pairs in dictionary, use the count property .

var dict = ["Red": 0, "Green": 1, "Blue": 2]
dict.count      // 3

Like arrays, dictionaries are value types and are copied on assignment or when passed to and from functions. Modifications to the copy do not affect the original.

var dict = ["Red": 0, "Green": 1, "Blue": 2]
var dictCopy = dict
dictCopy["Red"] = 4   // Does not affect "dict"
dict                  // "Red":0, "Green": 1, "Blue": 2
dictCopy              // "Red":4, "Green": 1, "Blue": 2
Sets

The third and final Swift collection type is Set . A Set is a collection of elements that has no defined ordering and in which each element can appear only once. Adding another instance of an element that is already present does not change the content of the set. In most other respects, a set is much like an array.

The syntax for initializing a set is the same as that used for arrays. To disambiguate, you need to explicitly state that you are creating a Set . Here are two (equivalent) ways to do that:

let s1 = Set([1, 2, 3])
let s2: Set<Int> = [1, 2, 3]

The contains() method returns a Bool that indicates whether a set contains a given element, and the count property holds the number of elements in the set.

s1.contains(1)    // true
s2.contains(4)    // false
s1.count          // 3

As you’ll see later, you can enumerate the elements of a set using a for loop.

To add an element to or remove an element from a set, use the insert() and remove() methods.

var s1 = Set([1, 2, 3])   // [2, 3, 1] (note that order does not matter in a set)
s1.insert(4)              // [2, 3, 1, 4]
s1.remove(1)              // [2, 3, 4]
s1.removeAll()            // [] (empty set)
NSArray, NSDictionary, and NSSet

The Foundation framework has Objective-C classes that represent arrays, dictionaries and sets— NSArray , NSDictionary , and NSSet . The relationship between these classes and their Swift counterparts is similar to that between NSString and String . In general, you can treat a Swift array as an NSArray , a Swift dictionary as an NSDictionary , and a Swift set as an NSSet . As an example, suppose you had an NSString like this:

let s: NSString  = "Red,Green,Blue"

Suppose also that you want to separate this into three separate parts, each containing one color name. NSString has a method called components(separatedBy: ) that will do exactly what you want (and so does String , but you have an NSString in this case, not a String ). This method takes the separator string as an argument and returns an NSArray containing the individual components .

let s: NSString = "Red,Green,Blue"
let components = s.components(separatedBy: ",")// Calls the NSString method
components      // ["Red", "Green", "Blue"]

Even though this method returns an NSArray , Swift is clever enough to map it to the corresponding Swift collection—an array of String s—so the inferred type of components is [String] , not [NSString] . You can confirm this by hovering the mouse over the variable name and clicking while holding down the ⌥ (Option) key.

You can directly create NSDictionary , NSSet , and NSArray instances in Swift code. Here’s an example:

let d = NSDictionary()

The inferred type of the variable d is, of course, NSDictionary . You can explicitly cast an NSDictionary (whether you created it or obtained it from a method in the Foundation framework or another framework) to the Swift Dictionary type using the as keyword (which I’ll say more about later).

let e = d as Dictionary

Now if you ⌥-click the name e , you’ll see that Swift infers a type of Dictionary<NSObject , AnyObject> for this variable, which is another way of saying its type is [NSObject: AnyObject] . What are these key and value types and where did they come from? An NSDictionary created in the preceding Swift code is type-free: the compiler does not know the types of the keys and values that might be added to it (the same applies to NSSet and NSArray ). The compiler has no choice but to infer a couple of general types: NSObject is the base class for all Foundation objects, and AnyObject is a Swift protocol (discussed later) that corresponds to any Swift class type—the type signature [NSObject: AnyObject] says “I have almost no idea what this dictionary contains.” When you retrieve elements from an NSDictionary or an NSArray in Swift, you usually have to use the as! operator (more on this later) to cast them explicitly to the correct types or cast the NSDictionary itself to the type that you know it must be. For example, if you know that an NSDictionary instance maps strings to strings, you can do this:

let d = NSDictionary()
let e = d as! [String: String]

Here, you cast the NSDictionary to [String: String] . This code works even if the dictionary actually contains NSString s instead of String s because Swift automatically maps between String and NSString . Beware, though: if the NSDictionary key and value types are not both what you claim they are, your application will crash. You may have noticed that in this example you performed the cast using as! instead of as . I’ll explain the difference between these two operators shortly.

There is a safer way to handle all of this that involves optionals, which is the subject of the next section.

Optionals

Let’s go back to an example that you used in the previous section on dictionaries .

var dict: [String: Int]
dict = ["Red": 0, "Green": 1,  "Blue": 2]
let value = dict["Red"]

Although the values in this dictionary are all of type Int , the inferred type for value is not Int , but Int? —an optional integer . The ? signals the optional nature of the type. What does optional mean and why is it being used here? To answer that, think about what should happen if you access the dictionary with a key for which there is no value.

let yellowValue = dict["Yellow"]

What value should be assigned to yellowValue ? Most languages address this by having a distinguished value that means, by convention, “no value.” In Objective-C this value is referred to as nil (which is really just a redefinition of 0); in C and C++ it’s NULL (again, a redefinition of 0); and in Java it’s null . The problem with this is that it can be dangerous to use a nil (or equivalent) value. In Java, for example, using a null reference causes an exception; in C and C++, the application is likely to crash. What’s worse, there’s no way to know from its declaration whether a variable might contain a null (or nil or NULL ) value. Swift solves this problem in a neat way: it has a nil value, but a variable (or constant) can be set to nil only if it’s declared as an optional or its type is inferred to be optional. As a result, you can tell immediately whether a variable or constant could be nil by examining its type: if it’s not optional, it can’t be nil . Further, Swift requires you to take that into account explicitly whenever you use the value .

Let’s look at some examples to make this clearer. Suppose you define a variable called color , like this:

var color = "Red"

Because of the way it’s defined, the inferred type is String , which is not optional. Therefore, it’s illegal to attempt to assign nil to this variable.

color = nil   // Illegal: color is not an optional type.

Because of this, you know for sure that you don’t need to worry about color having a nil value, ever. It also means that you can’t use this variable to hold a value returned from a dictionary, even if you know that value will not be nil .

let dict = [0: "Red", 1: "Green", 2: "Blue"]
color = dict[0]!    // Illegal: value of dict[0] is optional string, color is not optional.

To make this assignment legal, you have to change the type of color from String to optional String .

let dict = [0: "Red", 1: "Green", 2: "Blue"]
var color: String?     // "String?" means optional String
color = dict[0]        // Legal
print(color)           // What does this print?

How do you make use of the value assigned to the color variable? Enter the preceding code into the playground and you’ll see that what’s printed is not "Red" but Optional("Red") . The dictionary access doesn’t return the actual value; it returns the value “wrapped” as an optional. To get the string value, you need to “unwrap” the optional using the ! operator , like this:

let actualColor = color!   // "color!" means unwrap the optional

The inferred type of actualColor is String and the value that gets assigned to it is Red . It follows from this that whenever you retrieve a value from a dictionary, it’s going to be of optional type, and you have to unwrap it to get the value that you want. But remember, I said that nil references are dangerous; in Swift that translates as unwrapping optionals can be dangerous. Change your playground code to this:

let dict = [0: "Red", 1: "Green", 2: "Blue"]
let color = dict[4]
let actualColor = color!

Swift correctly infers that the type of color is String? , but when you unwrap the result of the dictionary access to assign the value to actualColor , you get an error. In the playground, this error is just reported to you; in an application, it would cause a crash. Why did this happen? Well, there is no entry in the dictionary with key 4, so the color variable was assigned the value nil . If you try to unwrap nil , you crash. You’re probably thinking that this is no improvement on what happens in other languages, but that’s not true. First, the fact that color is of optional type tells you that you must expect that it could be nil —and the converse (which is equally valuable). Second, Swift gives you a way to handle the case where the optional value is nil . In fact, it gives you several ways.

The first thing you can do is check whether you got nil from the dictionary access and only unwrap the value if you didn’t.

if color != nil {
    let actualColor = color!
}

This construction is so common that Swift has shorthand for it. Here’s the second way to handle optional unwrapping:

if let actualColor = color {
    // Executed only if color was not nil
    print(actualColor)
}

The code block associated with the if statement is executed only if color is not nil , and the unwrapped value is assigned to the constant actualColor . You can even make actualColor a variable by changing let to var .

if var actualColor = color {
    // Executed only if color was not nil. actualColor can be modified
    print(actualColor)
}

In these examples, you defined the new variable actualColor to receive the unwrapped value, which requires you to give it a new name. Sometimes, it can seem artificial to have to use a different name for what is really the same thing and, in fact, it isn’t necessary—we can actually give the new variable the same name as the optional variable that’s being unwrapped, like this:

if var color = color {
    // Executed only if the value of the original color variable was not nil
    print(color)    // Refers to the new variable, holding the unwrapped value
}

It’s important to realize that the new color variable is not related to the existing one and, indeed, it has a different type ( String instead of String? ). In the body of the if statement, the name color refers to the new, unwrapped variable, not the original one.

let dict = [0: "Red", 1: "Green", 2: "Blue"]
let color = dict[0]
if var color = color {
    // Executed only if color was not nil
    print(color)                            // "Red"
    color = "Green"                         // Reassigns the local variable
}                                           // New color variable is now out of scope
color                                       // Refers to the original value: "Red"

How about if you want to use a default value for a key that’s not present in the dictionary? Swift gives you a convenient way to do that too. Here’s the third way to handle optional unwrapping:

let dict = [0: "Red", 1: "Green", 2: "Blue"]
let color = dict[4]
let actualColor = color ?? "Blue"

The ?? operator (called the coalescing operator ) unwraps its left operand, if it’s not nil , and returns its value; otherwise, it returns its second operand. In this case, since color is nil , actualColor would be assigned the value Blue . Of course, you can contract the preceding code into two statements to make it slightly easier to read.

let dict = [0: "Red", 1: "Green", 2: "Blue"]
let actualColor = dict[4] ?? "Blue"

Dictionaries are not the only context in which optionals are used. If you look through the Swift API documentation, you’ll see plenty of methods that return optional values. It’s even possible for a type initializer to return an optional value. You’ve already seen an example of this; if you try to initialize an instance of an enumeration using an invalid raw value, the result is nil .

enum ResultType : String {
    case SUCCESS = "Success"
    case WARNING = "Warning"
    case ERROR = "Error"
}
let result = ResultType(rawValue: "Invalid")

The inferred type of result is ResultType? , and in this case, its value would be nil because there is no enumeration case that has the raw value Invalid .

You’ve learned that you have to be careful when unwrapping optionals , but sometimes that can be both inconvenient and unnecessary. As you’ll see as you try the examples in this book, it’s common to define a variable in a class that cannot be given a useful value while the class itself is being initialized, but that you know will have a valid value before your code needs to use it. In cases like that, you could define the variable as optional and unwrap it every time you use it. That keeps the compiler happy, but it means you have to keep adding ! operators everywhere or wrap the access in an if let construction, even though you know that the unwrapping will always succeed.

Fortunately, Swift lets you sidestep this. All you have to do is tell Swift that you want it to automatically unwrap the optional whenever you access it. Here’s how you would do that in your dictionary example:

let dict = [0: "Red", 1: "Green", 2: "Blue"]

var color: String!    // Notice the !
color = dict[0]       // Assigns Optional("Red")
print(color)          // Automatically unwraps the optional

The key to this code is that the color variable was declared to be of type String! , not String? . Variables declared this way are called implicitly unwrapped optionals . The ! tells Swift that you want it to assume that the variable will always have a non- nil value whenever you use it and to go ahead and unwrap it. That means you can write print(color) instead of print(color!) . Although you’re not saving much here, if you had to access the result more than once, you would end up typing fewer characters by using this feature.

Beware, however. You’ve now told Swift that color will never be nil . If it turns out that it is nil when you try to use it, Swift will unwrap it, and your application will crash.

You can use optionals to address another issue that came up while discussing dictionaries: how to handle values obtained from an NSDictionary . Let’s set the problem up by creating a Foundation dictionary with some initial values.

let d = NSDictionary(objects: ["Red", "Green", "Blue"], forKeys: [0 as NSCopying, 1 as NSCopying, 2 as NSCopying])

This code initializes an NSDictionary with a mapping from Int s to String s. In reality, of course, you wouldn’t create an NSDictionary and cast it like this; you would just create a Swift dictionary. But suppose you got the dictionary from a call to a Foundation method —perhaps it was populated from the content of a file. As long as the dictionary really does map Int s to String s, this code works fine, and you can access its content in the usual way:

let color = d[1]    // Gets an optional, wrapping "Green"

Note, however, that Swift doesn’t really know the type of the value that it got from the dictionary; it infers AnyObject? , which is an optional wrapping some kind of object. You can do better by explicitly casting the result to the correct type.

let color = d[1] as! String

But what if you got the type of the dictionary wrong? Maybe what you’ve actually got is a [Int: Int] . To see what happens, change the types of the keys in the first line from numbers to strings, like this:

let d = NSDictionary(objects: [ 0, 1, 2], forKeys: [0 as NSCopying, 1 as NSCopying, 2 as NSCopying])
let value = d[1] as! String

This code crashes when casting the value obtained from the dictionary to String . That’s a little drastic. You really want to be able to detect this condition and take some corrective action instead of crashing. You can do that by using the as? operator instead of as . The as? operator returns an optional: if its first operand is not of the type given by its second operand, it returns nil instead of crashing. So now you can do something like this:

let d = NSDictionary(objects: [ 0, 1, 2], forKeys: [0 as NSCopying, 1 as NSCopying, 2 as NSCopying])
if let value = d[1] as? String {  // as? returns nil if d is not of type String?
    print("OK")                   // As expected - use value as normal
} else {
    print("Incorrect types")      // Executed if d is not of type [Int: String]
}

There is another way to achieve the same effect. You can use the is keyword to check whether the dictionary is of the expected type before using it.

if d is [Int: String] {   // Evaluate to true if d maps Ints to Strings
    print("Is [Int: String]")
} else {
    print("Incorrect types")
}

You’ve probably noticed that you use both the as and as! operators when casting. What’s the difference? Roughly speaking, you use as when the cast is guaranteed to work and as! when it’s not—the ! expresses the fact that you are forcing the compiler to accept code that it would otherwise report an error for, such as when downcasting. Here’s an example of a safe cast, where you can use as :

let s = "Fred"
let n = s as NSString

The inferred type of s is String and you’re trying to cast it to NSString . Swift performs this bridging operation automatically, so you can use as in this case. Similarly, any upcast can be done with the as operator.

let label = UILabel()
let view = label as UIView

Here, label is of type UILabel , a UIKit class that represents a label, which is a user interface component that displays text. Every UIKit user interface component is a subclass of UIView , so you can freely upcast the label to its base class UIView with the as operator. The converse, however, is not true.

let view: UIView = UILabel()
let label = view as! UILabel    // Downcast requires !

This time, you created a UILabel , but you assigned it to a variable of type UIView . To cast this variable back to the type UILabel , you need to use the as! operator, because there is no guarantee that a variable of type UIView refers to a UILabel —it could be referencing another type of UIKit component , such as a UIButton . Here’s another example that you have already seen:

let d = NSDictionary(objects: ["Red", "Green", "Blue"], forKeys: [0 as NSCopying, 1 as NSCopying, 2 as NSCopying])
let color = d[1] as! String

As you saw earlier, when you recover a value from an NSDictionary , its type is inferred to be AnyObject? , which could refer to any Swift object type. To cast the value to String , you need to use the as! operator.

That’s enough about optionals for now. I’ll have more to say about this topic when I discuss calling methods in the upcoming “Properties” and “Methods” sections.

Control Statements

You’ve seen Swift’s data types and how you can initialize them and perform operations on them. Now let’s look at Swift’s control statements. Swift supports all of the control statements you find in most other languages and adds some interesting new features to some of them.

The if Statement

Swift’s if statement works just like it does in most other languages: you test a Boolean condition and execute some code only if it evaluates to true . You can optionally include an else block that executes if the condition is false . Here’s an example:

let random = arc4random_uniform(10)
if random < 5 {
    print("Hi")
} else {
    print("Ho")
}

The arc4random_uniform() function returns a random integer between 0 (inclusive) and its argument value (exclusive), so in this case any integer from 0 to 9. You test the returned value and print “Hi” if it’s less than 5 but print “Ho” if it’s not. Notice that Swift does not require you to put the test condition in parentheses, so either of these will work:

if random < 5 {  // Parentheses not required
}
if (random < 5) { // But can be used
}

By contrast to other languages, the code to be executed must be enclosed in braces, even if it’s only a single line. That means that this code is not valid in Swift :

if random < 5
    print("Hi")         // Invalid: must be in braces
else
    print("Ho")         // Invalid: must be in braces

Swift also has the ternary operator ?: , which may be familiar to you and which you probably either love or hate. This operator evaluates the Boolean expression before the ? and executes either the statement between the ? and the : if the result is true or the statement after the : if the result is false . You can use it to write the preceding code like this:

let random = arc4random_uniform(10)
random < 5 ? print("Hi") : print("Ho")

In this case, you can shorten the code even more by observing that all you’re doing is printing one string or the other and write this instead:

let random = arc4random_uniform(10)
print(random < 5 ? "Hi" : "Ho")

Depending on your point of view, either that’s much clearer than the code you started with or it’s impossible to read.

You’ve already seen that there is a special form of the if statement that simplifies the handling of optionals.

let dict = [0: "Red", 1: "Green", 2: "Blue"]
let color = dict[0]
if let color = color {
    // Executed only if color was not nil
    print(color)                            // "Red"
}

You can actually unwrap more than one optional in a single if let or if var statement.

let dict = [0: "Red", 1: "Green", 2: "Blue", 3: "Green", 4: "Yellow"]
let color1 = dict[Int(arc4random_uniform(6))]
let color2 = dict[Int(arc4random_uniform(6))]
if let color1 = color1, color2 = color2 {
    // Executed only if both colors were not nil
    print("color1: (color1), color2: (color2)")
}

This code generates a pair of random keys in the range 0 through 5 and uses them to get color strings from the dictionary. Since there is no entry with key 5, it’s possible that either (or both) of the values that you get are nil . The compound if let statement lets you safely unwrap both values and executes its body only if both were not nil . You can also include a test condition by adding a where clause.

let dict = [0: "Red", 1: "Green", 2: "Blue", 3: "Green", 4: "Yellow"]
let color1 = dict[Int(arc4random_uniform(6))]
let color2 = dict[Int(arc4random_uniform(6))]
if let color1 = color1, color2 = color2 where color1 == color2 {
    // Executed only if both colors were the same
    print("color1: (color1), color2: (color2)")
}

You can even include a test before unwrapping the optionals.

let dict = [0: "Red", 1: "Green", 2: "Blue", 3: "Green", 4: "Yellow"]
let color1 = dict[Int(arc4random_uniform(6))]
let color2 = dict[Int(arc4random_uniform(6))]
if dict.count > 3, let color1 = color1, color2 = color2 where color1 == color2 {
    print("color1: (color1), color2: (color2)")
}
The for Statement

Swift used to contain two variants of the for statement . The first, very much like the one that will be familiar to anybody who has worked with a C-based language, has been deprecated in Swift 3 and is no longer valid.

for var i = 0; i < 10; i += 1 {
    print(i)
}

The current acceptable form allows you to iterate over a sequence of values, such as a range or a collection. This code produces the same result as the for loop shown earlier.

for i in 0..<10 {
    print(i)
}

Notice that you don’t need to use var to introduce the variable when using this form. You can create and iterate over a more general range by using the stride() method . Here’s an example that prints the even integers from 10 down to 0, inclusively:

for i in stride(from: 10, through: 0, by: -2) {
    print(i)
}

Looping over the elements of an array is very simple, and the intent of the code is more obvious than it would be with an indexed loop.

let strings = ["A", "B", "C"]
for string in strings {
    print(string)
}

The same construction also works for sets, although the iteration order is undefined since sets do not provide any ordering.

let strings = Set<String>(["A", "B", "C"])
for string in strings {
    print(string)
}

You can iterate over the keys of a dictionary by using its keys property. As with sets, the iteration order is undefined.

let d = [ 0: "Red", 1: "Green", 2: "Blue"]
for key in d.keys {
    print("(key) -> (d[key])")
}

You can do the same thing more directly by iterating the dictionary as a set of key-value pairs.

for (key, value) in d {
    print("(key) -> (value)")
}

Each key-value pair is returned as tuple with two elements , where the name key is linked to the first element of the tuple and the name value to the second. Refer to the Swift Programming Language book for further discussion of tuples.

The repeat and while Statements

The repeat and while statements are the same as the do and while statements in C, C++, Java, and Objective-C. They both execute a body of code until a condition is met; the difference is that the while statement tests the condition before each pass of the loop, whereas repeat tests it at the end of each pass.

var i = 10
while i > 0 {
    print(i)
    i -= 1
}


var j = 10
repeat {
    print(j)
    j -= 1
} while j > 0
The switch Statement

The Swift switch statement is very powerful. I don’t have space here to talk about all of its features, but you should definitely read about it in more detail in Apple’s Swift Programming Language book. I’ll illustrate just the most important features with a few examples.

You can use the switch statement to select a code path based on one of several possible values of a variable or expression. For example, this code prints something different based on the value of the value variable:

let value = 11
switch value {
case 2, 3, 5, 7, 11, 13, 17, 19:
    print("Count is prime and less than 20")


case 20...30:
    print("Count is between 20 and 30")


default:
    print("Greater than 30")
}

There are several points to note about this code. First, a case can have multiple possible values, separated by commas. The case is executed if the switch expression has any of the listed values. Second, the case value can be a range. In fact, the switch statement is capable of some very powerful pattern matching, the details of which are covered in Apple’s documentation. Third, control does not pass from one case into another, as it does in most other languages. That means that the preceding example will execute only one case and print only once; it is not necessary to include a break statement between cases in a switch. If you really want to continue execution from one case into the following case, you can do so by adding a fallthrough statement at the end of the first case.

The case list must be exhaustive: if the default case had not been included in the preceding code, the compiler would have flagged an error. Furthermore, every case must have at least one line of executable code. That means that the following code is not legal (and is also misleading):

switch (value) {
case 2:
case 3:  // Illegal - previous case is empty.
    print("Value is 2 or 3")
default:
    print("Value is neither 2 nor 3")
}

The correct way to write that code is to include both 2 and 3 in the same case.

switch (value) {
case 2, 3:   // Correct: catches value 2 and value 3
    print("Value is 2 or 3")
default:
    print("Value is neither 2 nor 3")
}

Alternatively, you can use fallthrough .

switch (value) {
case 2: fallthrough
case 3:  // Illegal - previous case is empty.
    print("Value is 2 or 3")
default:
    print("Value is neither 2 nor 3")
}

The switch expression does not have to be numeric. Here’s an example that switches based on the value of a string:

let s = "Hello"
switch s {
case "Hello":
    print("Hello to you, too")


case "Goodbye":
    print("See you tomorrow")


default:
    print("I don't understand")
}

The next example uses the Status enumeration that defined earlier and shows how to get access to the associated value of an enumeration case that has one:

enum Status {
    case OK
    case ERROR(String)
}
let result = Status.ERROR("Network connection rejected")
switch (result) {
case .OK:
    print("Success!")


case .ERROR(let message):
    print("Ooops: (message)")
}

Since the compiler knows that the type of the switch expression is Status , there is no need to fully qualify the case values; you can say case .OK instead of case Status.OK . The compiler also knows that the enumeration has only two possible values, and since both of those values are listed as cases, there is no need to add a default case. Notice the form of the .ERROR case; the .ERROR(let message) causes the compiler to extract the associated value of the ERROR and assign it to a constant called message , which is valid only in the scope of the case itself. If the enumeration has more than one associated value, you can get all of the values by including one let statement for each, separated by commas .

Functions and Closures

Unlike many other languages , Swift uses a keyword ( func ) to denote a function. To define a function, you need to give its name, its argument list, and its return type. This function calculates and returns the area of a rectangle given the lengths of its sides.

func areaOfRectangle(width: Double, height: Double) -> Double {
    return width * height
}

The function arguments are enclosed in parentheses, separated by commas, and written in the same way as variable declarations—that is, name followed by type. Unlike variable declarations, though, specifying the type of an argument is not optional. If the function has no arguments, the parentheses must be empty.

func hello() {
    print("Hello, world")
}

If the function returns a value, the type of that value must be given, preceded by the symbol -> . In this case, the arguments are both Double s, as is the return value. If the function doesn’t return anything, you can either omit the return type (as shown in the definition of the preceding hello() function) or write it as -> Void . Here’s a function that either does nothing or prints its argument, depending on the value of the debug variable, and returns nothing:

let debug = true   // Enables debugging
func debugPrint(value: Double) {
    if debug {
        print(value)
    }
}

The definition of this function could also be written slightly more verbosely, like this:

func debugPrint(value: Double) -> Void {  // "-> Void" is optional

To invoke a function, refer to it by name and supply the appropriate arguments.

let area = areaOfRectangle(width: 20, height: 10)

Prior to Swift 3, it was acceptable to omit the name of the first argument as follows:

let area = areaOfRectangle(20, height: 10)   // no longer valid as of Swift 3

Another feature of Swift is that function arguments can have two names—an external name (the name that’s used by the function’s caller) and an internal name (the name that’s used in the body of the function). It’s always optional to supply an external name. If you don’t supply one, the external name is taken to be the same as the internal one. Here’s another way to write the areaOfRectangle() function , this time with both external and internal argument names:

func areaOfRectangle(width w: Double, height h: Double) -> Double {
    return w * h
}

When you specify both an external and an internal argument name, the external name comes first; if you supply only one argument name, then it is the internal argument name, and there is no external name. Notice that the body of the code uses the internal argument names ( w and h ), not the external names ( width and height ). So, why would you want to use external argument names? This feature is partly motivated by the naming conventions used for Objective-C methods, which need to be mapped by the compiler so that they can be called from Swift. You’ll say more about that when you examine Swift classes later in this appendix. In this example, the only benefit of adding external names is that if they exist, the caller is required to supply them when invoking the function, which makes the code more readable.

let area = areaOfRectangle(width: 20, height: 10)   // Now "width" and "height" are mandatory

You can provide a default value for a function argument by including it in the argument list. The following function breaks an input string into components separated by the given delimiter and defaults the delimiter to a space if it’s not given:

func separateWords(str: String, delimiter: String = " ") -> [String] {
    return str.components(separatedBy: delimiter)
}

You can call this function without supplying an explicit delimiter, in which case a single space is used as the delimiter.

let result = separateWords(str:"One small step")
print(result)    // [One, small, step]

Swift automatically supplies an external name for an argument with a default value, making it the same as the internal name (although you can override this by supplying your own external name). That means the argument name must be used if its value is not defaulted.

let result = separateWords(str: "One. Two. Three", delimiter: ". ")  // "delimiter" is required
print(result)    // [One, Two, Three]

If you really don’t want to force the user to include the argument name , you can write the external name as _ , although this is not recommended because it reduces readability.

func separateWords(str: String, _ delimiter: String = " ") -> [String] {
    return str.components(separatedBy: delimiter)
}
let result = separateWords(str: "One. Two. Three",  ". ")  // "delimiter" is required
print(result)    // [One, Two, Three]

You can use this to change the areaOfRectangle() function so that neither argument name needs to be supplied.

func areaOfRectangle(_ w: Double, _ h: Double) -> Double {
    return w * h
}
let area = areaOfRectangle(20, 10)

Notice that it is necessary to precede the first argument with an _ if you want to use an unnamed argument first.

func areaOfRectangle(_ w: Double, _ h: Double) -> Double {
    return w * h
}

In Swift, functions are types, so you can create a variable of function type, assign a reference to a function to it, and use that variable to call the function . Similarly, you can pass a function as an argument to another function or return a function from a function.

To declare a function variable, you specify the function’s signature as the type of the variable. The signature consists of the function’s argument types in parentheses (unless there is just one argument, when the parentheses can be omitted), followed by -> , followed by the return type. The following code creates a variable that can hold a reference to a function that performs an unspecified operation on a Double and returns another Double :

var operation: (Double) -> Double

For one function arguments, previous versions of Swift allowed omitting the parentheses, but this is no longer valid.

var operation: Double -> Double                   // No Longer valid as of Swift 3

You can write functions that operate on a Double and assign any of those functions to the variable. Here’s an example:

func doubleMe(number: Double) -> Double {
    return 2 * number
}
operation = doubleMe

Now you can invoke the function using the function variable, supplying the argument as if you were directly calling the function.

operation(2)    // Result is 4

You can make the operation variable refer to a different function and perform a different operation using the same call expression.

func quadrupleMe(number: Double) -> Double {
    return 4 * number
}
operation = quadrupleMe
operation(2)    // Result is 8

The ability to pass functions around in this way is very powerful. There are several Swift methods that accept function arguments. One of them is the sort(by: ) method, which sorts an ordered collection based on an ordering provided by a function that’s passed as its argument. The ordering function is required to accept two arguments, which are elements of the collection being sorted, and return the Bool value true if the first argument is less than the second and false otherwise. Here’s an example of such a function that compares two Int s:

func compareInts(_ first: Int, _ second: Int) -> Bool {
    return first < second
}

Now you can create an array of Int s and use sort() and the compareInts() function to sort them. To do so, pass the compareInts() function an argument to sort() , like this:

var values = [12, 3, 5, -4, 16, 18]
let sortedValues = values.sort(by: compareInts)
sortedValues   // Result:  [-4, 3, 5, 12, 16, 18]

This probably looks ridiculously complex at first, so let’s break it down. The comparison function must be enclosed in braces. After that, the first part of the definition is just its argument list and its return type, followed by the keyword in , which separates the arguments and return type from the function body.

{(first: Int, second: Int) -> Bool in

Next, you have the body of the function, which is the same as the original code from the compareInts() function, followed by the closing brace and the parenthesis that closes the argument list of the sorted() method.

    return first < second
})

There’s a name for this kind of anonymous function that’s written in place: it’s called a closure . Once you’re used to how it works, you’ll probably find yourself making a lot of use of closures. Other languages also support this capability such as in Python where it would be called a lambda .

If a closure is the final argument of a function, Swift lets you clean the syntax up a bit by taking it outside the function’s argument list, like this:

let sortedValues = values.sorted() {   // The closure is now outside the parentheses
        (first: Int, second: Int) -> Bool in
             return first < second
    }

That’s still quite a lot of code. Fortunately, you can clean it up a little more. Swift can infer that the closure requires two Int arguments and must return a Bool . It knows this because of the way in which the sort() method is defined in the standard library. Because of this, you can omit the argument types, the parentheses around the argument names, and the return type, leaving you with just this:

let sortedValues = values.sorted() {
    first, second in   // Swift infers the argument types and return type!
    return first < second
}

That’s much better. But you can take it one step further by omitting the argument names too. Swift knows there are two arguments, and if you don’t name them, it calls them $0 and $1 (and $2 , $3 , etc., if there were more). That lets you reduce your closure to just one line of code.

let sortedValues = values.sorted() { return $0 < $1 }

That’s not quite the end. Swift also lets you drop the return keyword. So, finally you get to this:

let sortedValues = values.sorted() { $0 < $1 }

I think you’ll agree, that’s a lot more expressive than what you started with. Or at least it is once you’re used to reading the somewhat terse syntax. Experiment with this in the playground, try out some variations, and see what works and what doesn’t.

If you’re wondering why closures are called closures, it’s because they “close over” variables that are in their scope when they are created. That means that they can read and even write those variables. It’s difficult to appreciate how useful this is without the correct context. You’ll see examples in the rest of the book that illustrate the point. For now, let’s just demonstrate that you can write a closure that uses a value that’s defined outside of that closure. Take a look at the following code:

func getInterestCalculator(rate: Double) -> (Double, Int) -> Double {
    let calculator = {
        (amount: Double, years: Int) -> Double in rate * amount * Double(years)
    }
    return calculator
}

The function signature tells you that the getInterestCalculator() function requires an argument of type Double and returns a function. The returned function requires two arguments—a Double and an Int —and it returns a Double .

What you’re actually doing here is passing an interest rate to the getInterestCalculator() function, and it’s going to return to you a function that will calculate simple interest at that given rate.

Inside the getInterestCalculator() function, you create a closure and assign it to the calculator variable.

let calculator = {
        (amount: Double, years: Int) -> Double in rate * amount * Double(years)
    }

As you can see, the closure function requires the amount as a Double , and the period over which interest will be calculated in years as an Int . The most important point to notice is that the body of the closure uses the rate argument that was passed to the getInterestCalculator() function. Finally, the closure is returned to the caller of getInterestCalculator() .

Now let’s write some code that calls this function and uses the function that it returns.

let calculator = getInterestCalculator(rate: 0.05)
calculator(100.0, 2)   // Result is 10: interest at 5% on $100 over 2 years.

The returned function is assigned to the calculator constant, and then it’s invoked to compute the interest on $100 over two years, at an interest rate of 5 percent. So, what’s so interesting about this? Well, think about what is happening here. The returned closure is referencing the value of the rate argument of the getInterestCalculator() function, but it’s doing so after that function has returned. How is that possible? It works because the closure captures the function argument by referencing it. When a variable is captured by a closure as the closure is being created, a copy of its value is taken, and that copy is used when the closure is executed. That’s how the interest rate value that was passed as an argument to getInterestCalculator() is made available to the closure after the argument itself no longer exists.

Error Handling

If you scan through the Xcode documentation page for the NSString class, you’ll come across several methods declarations that include a throws clause, like this one:

init(contentsOfFile path: String, encoding enc: UInt) throws

Whenever you see a throws clause, it means that the method reports an error that you can choose to ignore or to handle by catching it. You’ll first of all see how you might ignore it, and then you’ll look at how to catch and handle the error. Let’s try to ignore it by just pretending the throws clause is not there.

let s = String(contentsOfFile: "XX", encoding: String.Encoding.utf8)

If you type that into the playground, you’ll see the “Call can throw but is not marked with ‘try’” error. To make the compiler accept this call, you have to add a try clause. There are three variants of try , two of which allow you to ignore the error and a third that is used when you intend to catch it. Let’s continue to ignore the potential error.

let s = try? String(contentsOfFile: "XX", encoding: String.Encoding.utf8)

That gets rid of the compilation error. Now the playground executes the statement and shows the result nil . When you use try? , you’re converting the return type of the method that you’re calling into an optional. Since this method is actually an initializer for the String class (which String actually gets from NSString ), the return type is converted to String? , and that is the inferred type of the variable s . In this case, the value is nil because the file XX doesn’t actually exist.

You can use a try? clause in an if statement to do something only if the file exists and its content was successfully loaded.

if let s = try? String(contentsOfFile: "XX", encoding: String.Encoding.utf8) {
    print("Content loaded")
} else {
    print("Failed to load contents of file")
}

If you’re sure that the file you are trying to read exists and its content can be read, you can replace try? with try! , like this:

let s = try! String(contentsOfFile: "XX", encoding: String.Encoding.utf8)

Although this is legal syntax, it’s not good practice because your application would crash if anything went wrong—you can see that by trying this statement in the playground.

Catching Errors

You’ve seen that if you use try? as part of an if let statement , you can find out whether the operation completed correctly, and you can take some different action if it wasn’t. The try? statement implicitly tells you that an error occurred by returning a nil value, but there is no way to find out what that error was. To do that, you have to use the try statement and wrap it in a do - catch block, like this:

do {
    let s = try String(contentsOfFile: "XX", encoding: String.Encoding.utf8)
    print("Loaded content (s)")
} catch {
    print(error)
}

The statements inside the do block are executed to completion or until one of them throws an error, at which point control transfers to the catch block. The init(contentsOfFile:encoding:) initializer throws a value of type NSError , which is the Foundation framework’s generic error type. Inside the catch block, you can get the value of the error from the error variable , as shown in the preceding example.

Throwing an Error

Any function or method can throw an error , provided that it declares that it does so by including a throws clause in its definition. The thrown value can be any type that adopts the ErrorType protocol, as NSError does—in fact, if you check the inferred type of the error variable in the preceding example, you’ll find that it is ErrorType . Errors thrown by methods in the Foundation framework (and other Apple frameworks) are of type NSError , but you are free to define custom error types in your own code. It’s common to use an enumeration for this purpose because it can conveniently represent one or more error cases and even include additional information about the error.

As an example, let’s write a function that calculates the length of the third side of a triangle given the lengths of the other two sides and the angle between them. You’re going to insist that the values of the arguments that correspond to the lengths of the sides must both be positive and the angle must be between 0 and π radians. Let’s start by writing the function without any error checking.

func calcThirdSide(_ side1: Double, side2: Double, angle: Double) -> Double {
    return sqrt(side1 * side1 + side2 * side2 - 2 * side1 * side2 * cos(angle))
}

You’re using the cosine rule to calculate the length of the third side. To check that the implementation is correct, let’s try it out on a right-angled triangle with sides of length 3 and 4.

let side3 = calcThirdSide(3, side2: 4, angle: Doule.pi /2)
print(side3)

Pythagoras’s theorem tells you that the length of the third side in this case should be 5, and that’s the result you’ll see in the playground if you run this code. Now let’s start adding error checking. You have two different types of condition that you need to check—the lengths of the sides and the value of the angle. This is a natural fit for an enumeration, so let’s define one.

enum TriangleError : Error {
    case SideInvalid(reason: String)
    case AngleInvalid(reason: String)
}

Since you’re going to throw instances of this enumeration, it is required to conform to Error . You defined cases for each of the types of error that you’ll check to provide an error message, so both cases have an associated string value.

Before you can add error checking to your function, you have to tell the compiler that it might throw an error. To do that, you add the throws keyword to the function definition. This keyword must be placed after the function’s argument list and before its return type (if it has one).

func calcThirdSide(_ side1: Double, side2: Double, angle: Double) throws  -> Double {
    return sqrt(side1 * side1 + side2 * side2 - 2 * side1 * side2 * cos(angle))
}

As soon as you add the throws keyword, the compiler starts complaining that the function call is not made in a try statement. Let’s fix that by adding some code to catch the error.

do {
    let side3 = try calcThirdSide( 3, side2: 4, angle: Doule.pi /2)
    print(side3)
} catch {
    print(error)
}

Now you can start adding error checks to the calcThirdSide(side1:side2:angle:) function. Modify the function definition to the following:

func calcThirdSide(_ side1: Double, side2: Double, angle: Double) throws  -> Double {
    if side1 <= 0 {
        throw TriangleError.SideInvalid(reason: "Side 1 must be >= 0, not (side1)")
    }
    return sqrt(side1 * side1 + side2 * side2 - 2 * side1 * side2 * cos(angle))
}

The if statement tests whether the value of the side1 argument is zero or negative and, if so, uses the throw keyword to throw an instance of your TriangleError enumeration with an appropriate message. To test whether this works, change the value of the side1 argument in the test code from 3 to -1.

let side3 = try calcThirdSide(-1, side2: 4, angle: Doule.pi /2)

You should see the text SideInvalid("Side 1 must be >= 0, not -1.0") in the playground’s results area, indicating that the correct error was thrown and caught.

Now let’s add the other three error checks to the calcThirdSide(side1:side2:angle:) function.

func calcThirdSide(_ side1: Double, side2: Double, angle: Double) throws -> Double {
    if side1 <= 0 {
        throw TriangleError.SideInvalid(reason: "Side 1 must be >= 0, not (side1)")
    }


    if side2 <= 0 {
        throw TriangleError.SideInvalid(reason: "Side 2 must be >= 0, not (side2)")
    }


    if angle < 0 {
        throw TriangleError.AngleInvalid(reason: "Angle must be >= 0, not (angle)")
    }


    if angle >= Doule.pi {
        throw TriangleError.AngleInvalid(reason: "Angle must be <= π, not (angle)")
    }


    return sqrt(side1 * side1 + side2 * side2 - 2 * side1 * side2 * cos(angle))
}

Experiment with the arguments passed to the calcThirdSide(side1:side2:angle:) function to verify that these checks work.

The guard Statement

It’s quite common to have argument checking code like this at the start of a function. Swift gives you another way to express these error tests—you can use the guard statement instead of an if statement. Here’s how you would rewrite the calcThirdSide(side1:side2:angle:) function to use guard instead of if :

func calcThirdSide(_ side1: Double, side2: Double, angle: Double) throws  -> Double {
    guard side1 > 0 else {
        throw TriangleError.SideInvalid(reason: "Side 1 must be >= 0, not (side1)")
    }


    guard side2 > 0 else {
        throw TriangleError.SideInvalid(reason: "Side 2 must be >= 0, not (side2)")
    }


    guard angle >= 0 else {
        throw TriangleError.AngleInvalid(reason: "Angle must be >= 0, not (angle)")
    }


    guard angle < Double.pi else {
        throw TriangleError.AngleInvalid(reason: "Angle must be <= ð, not (angle)")
    }


    return sqrt(side1 * side1 + side2 * side2 - 2 * side1 * side2 * cos(angle))
}

The body of the guard statement must be preceded by the keyword else and is executed only if the tested condition is not met. You can think of the meaning of guard as “unless this condition is met, execute the statement body.” Because of that, the sense of test must be the opposite of what would be tested by an if statement. For example, the condition tested by the first if statement was side1 <=0 , whereas the condition for the equivalent guard statement is side1 > 0 . This might seem strange at first, but once you get used to it, you’ll see that the guard version of the code is clearer because you’re stating the conditions that need to be met in order for execution to proceed, not the inverse condition.

The general form of the guard statement is as follows:

guard expression else {
    // Guard body statements
    // Transfer of control outside the scope containing the guard
}


// Control must not reach here if the guard body was executed

The guard body can include as many separate statements as required, provided that one condition is met—at the end of the statement body, control must transfer outside the immediate scope of the guard statement. In the preceding example, the guard statement is in the scope of the calcThirdSide(side1:side2:angle:) function, so control must be transferred out of that function at the end of the guard block. Here, you achieve that by throwing an error, but you could also return from the function. If the guard block is contained in a for statement, the immediate scope is the for statement, and you can use either a continue statement or a break statement to meet the requirements of the guard statement. The same applies to repeat and while statements. If you allow the flow of control to continue from the end of the guard block into the statements that follow it, you will get a compiler error .

More on Error Catching

So far, you’ve used a single, generic catch block to capture and print any error that’s thrown from the calcThirdSide(side1:side2:angle:) function. More generally, a do - catch statement can have multiple catch blocks, and each catch block can have an expression that is matched against the error that is thrown to select the block that should be executed. If none of the catch block expressions matches the error, then the block without an expression is used; if there is no such block, the error is thrown to the caller of the function or method containing the do - catch statement, and that function or method must declare that this may happen by including a throws clause in its definition. Let’s look at some examples.

Change the do - catch block in the playground as follows:

do {
    let side3 = try calcThirdSide( -1, side2: 4, angle: Doule.pi /2)
    print(side3)
} catch let e as TriangleError {
    print(e)
}

Here, you’ve added an expression to the catch block that causes it to catch only errors that are of type TriangleError . The error itself is assigned to the variable e , which is in scope only in the catch block. Since the calcThirdSide(side1:side2:angle:) function only throws errors of this type, you don’t need any further catch blocks . If you wanted to handle specific types of error differently, you simply add more cases. Here’s an example:

do {
    let side3 = try calcThirdSide( -1, side2: 4, angle: Doule.pi /2)
    print(side3)
} catch TriangleError.SideInvalid(let reason) {
    print("Caught invalid side: (reason)")
} catch {
    print("Caught (error)")
}

The first catch block handles the SideInvalid case and assigns the error message from the enumeration value to the variable reason so that it can be used in the body of the catch block . The second catch block has no expression, so it captures any error that’s not handled by earlier blocks. In this case, that corresponds to the AngleInvalid case. When a catchall block like this last one is present, it must be the final catch block, so this is invalid:

do {
    let side3 = try calcThirdSide(-1, side2: 4, angle: Doule.pi /2)
    print(side3)
} catch {  // Invalid - this must be the last catch block
    print(“Caught: (error)”)
} catch TriangleError.SideInvalid(let reason) {
    print("Caught invalid side: (reason)")
}

To handle each case individually, just give each one its own catch block.

do {
    let side3 = try calcThirdSide(-1, side2: 4, angle: - Doule.pi /2)
    print(side3)
} catch TriangleError.AngleInvalid(let reason) {
    print("Caught invalid angle: (reason)")
} catch TriangleError.SideInvalid(let reason) {
    print("Caught invalid side: (reason)")
}

Since you have explicitly handled both of the possible errors that the calcThirdSide(side1:side2:angle:) function may throw, there is no need to add a catchall catch block.

Classes and Structures

Swift provides two different ways to create custom types—classes and structures. Both may contain properties, initializers, and methods. A property is a variable defined within the body of a class or structure, a method is a function defined in a class or structure, and an initializer is a special type of method that is used to establish the initial state of a class or structure instance while it’s being created.

Structures

Here’s an example of a structure that represents a circle with a given radius:

struct CircleStruct {
    var radius: Double


    func getArea() -> Double {
        return Double.pi * radius * radius
    }


    func getCircumference() -> Double {
        return 2 * Double.pi * radius
    }
}

The circle has one property that holds its radius and two methods that return its area and circumference.

Swift automatically creates an initializer for a structure that assigns values to its properties using the initializer’s arguments. Here’s how you would use that initializer to create an instance of CircleStruct :

var circleStruct = CircleStruct(radius: 10)

The synthesized initializer for a structure has one argument for each property. The argument names are the same as the property names, and they appear in the order that the properties are defined in the structure itself. Notice that the argument names are required when using the initializer because the initializer arguments have both external and internal names.

Once you have created a structure instance, you can directly read and modify the properties using the property name. This code reads the radius of the circle and then doubles it.

var circleStruct = CircleStruct(radius: 10)
let r = circleStruct.radius          // Reads the radius property - result = 10
circleStruct.radius = 2 * r          // Doubles the radius.

Structures are value objects, so the following code creates a copy of the original CircleStruct object and assigns it to the newCircleStruct variable. Changes made to the radius property using the newCircleStruct variable do not affect the original, and vice versa.

var newCircleStruct = circleStruct   // Copies the structure
newCircleStruct.radius = 32          // Affects only the copy
newCircleStruct.radius               // New value: 32
circleStruct.radius                  // Old value: 20

If you assign a structure to a constant using a let statement, all of its properties become read-only.

let constantCircleStruct = CircleStruct(radius: 5)
constantCircleStruct.radius = 10    // Invalid: constantCircleStruct is constant

Swift requires that all properties of a structure (or class) be initialized before the initializer finishes execution. You can choose to set property values in the initializer itself or as part of the property definition. Here’s a slightly different implementation of the CircleStruct structure that initializes the radius to a default value of 1 when it’s defined:

struct CircleStruct {
    var radius: Double = 1


    init() {
    }


    init(radius: Double) {
        self.radius = radius
    }


    func getArea() -> Double {
        return Doule.pi * radius * radius
    }


    func getCircumference() -> Double {
        return 2 * Doule.pi * radius
    }
}

Notice that the structure now has two initializers (initializers are always called init ): one that takes no arguments and another that takes the radius as its argument . The first initializer lets you create an instance of the structure using the default radius set by the definition of the radius property.

let circleStructDefault = CircleStruct()
circleStructDefault.radius    // Result is 1

The second initializer assigns its argument to the radius property.

init(radius: Double) {
    self.radius = radius
}

Before you added the zero-argument initializer, you didn’t need to write this one because Swift created it for you; but it does not do that if you add initializers of your own. Notice that the assignment to the property uses the form self.radius . The self variable represents the instance of the structure that’s being initialized. In method calls, it represents the instance on which the method was invoked. Usually, you don’t need to qualify the property access with self , but in this case you need to do so because the initializer argument has the same name as the property.

As noted, by default, Swift requires you to use the initializer argument name when creating a structure instance (as you’ll soon see, the same applies to classes). When you define your own initializer, you can opt out of this by using an underscore ( _ ) as an external argument name, as shown by the following modification to the second CircleStruct initializer:

init(_ radius: Double) {
    self.radius = radius
}

With this change, you must use the initializer like this:

var circleStruct = CircleStruct(10)   // Argument name must be omitted

The implementations of the getArea() and getCircumference() methods don’t introduce anything new; they just perform a simple calculation using the value of the radius property. Notice that here you don’t use self when reading the property value, although you could. This version of the getArea() method is equivalent to the one shown previously:

func getArea() -> Double {
    return Doule.pi * self.radius * self.radius  // Explicit use of "self" - not recommended
}

You invoke these methods just like any other function, except that an instance of the structure is required.

let circleStructDefault = CircleStruct()
circleStructDefault.getArea()            // Returns the area
circleStructDefault.getCircumference()   // Returns the circumference

Classes

Creating a class is syntactically similar to creating a structure, but there are a few differences to be aware of. Here’s an implementation of a circle as a class:

class CircleClass {
    var radius: Double = 1


    init() {
    }


    init(radius: Double) {
        self.radius = radius
    }


    func getArea() -> Double {
        return M Double.pi * radius * radius
    }


    func getCircumference() -> Double {
        return 2 * Double.pi * radius
    }
}

The only syntactic difference between this and the structure version is the keyword class instead of struct , but there are some differences in the way that Swift handles class and structure initializers .

  • Swift does not create an initializer that sets the initial values of the properties of a class. Instead, it creates an empty init() initializer.

  • As with structures, if you add initializers of your own, you no longer get the free init() initializer.

In the case of CircleClass , the presence of the init(radius: Double) initializer means that Swift would not generate the init() version, so you had to add it yourself.

You can use either initializer to create a CircleClass instance, depending on whether you want to set the radius.

var circleClassDefault = CircleClass()        // Sets the default radius
circleClassDefault.radius                     // Result is 1
var circleClass = CircleClass(radius: 10)     // Explicitly set the radius
circleClass.radius                            // Result is 10

Classes are not value objects, so assigning a class instance to a variable or passing one to a function does not create a copy, as the following code demonstrates:

var newCircleClass = circleClass    // Does not copy
newCircleClass.radius = 32          // Only one copy, so this change is visible...
newCircleClass.radius               // ...through both references. Result is 32
circleClass.radius                  // Result is 32

Properties

The radius property of your circle is called a stored property because the value is stored with the class or structure. It’s also possible to have computed properties , which don’t have storage of their own. Instead, you calculate the value of the property every time it’s read. The area and circumference of a circle could be regarded as properties, so you could reasonably reimplement them as computed properties. Here’s how you would do that for CircleClass (the implementation would be the same for CircleStruct ):

class CircleClass {
    var radius: Double = 1
    var area: Double {
        return Double.pi * radius * radius
    }


    var circumference: Double {
        return 2 * Double.pi * radius
    }


    init() {
    }


    init(radius: Double) {
        self.radius = radius
    }
}

The syntax is very simple: you state the property name and its type (which is mandatory for a computed property), followed by a code block containing the code required to calculate the property value. With area and circumference as properties, you can get their values with slightly fewer keystrokes than when using a method.

let circleClass = CircleClass(radius: 10)
circleClass.area
circleClass.circumference

You are actually using a shortcut in the implementation of these properties; the full form of the area property, for example, would be as follows:

var area: Double {
    get {
        return Double.pi * radius * radius
    }
}

The difference is the get keyword and the additional set of braces around the code that calculates the property value. Since area is a read-only property, you haven’t implemented a setter, so Swift allows you to omit this extra boilerplate.

It’s perfectly possible to regard area as a settable property. If a new area is set, you can calculate and store the corresponding radius—and similarly for circumference . To make a property settable, you need to add a set block and put back the get boilerplate if you omitted it. Here’s how you would implement the setters for area and circumference :

var area: Double {
    get {
        return Double.pi * radius * radius
    }


    set {
        radius = sqrt(newValue/Doule.pi)
    }
}


var circumference: Double {
    get {
        return 2 * Double.pi * radius
    }


    set {
        radius = newValue/(2 * DOUBLE.PI)
    }
}

In the implementation of the setter, you get the value that’s being set from a variable called newValue . If you don’t like that name, you can choose one of your own by declaring it after the set keyword.

set (value) {
    radius = value/(2 * Double.pi)
}

Now that these properties are settable, you can use them to find out the radius for a given circumference or area.

circleClass.area = 314
circleClass.radius       // Radius for area 314 is 9.997
circleClass.circumference = 100
circleClass.radius       // Radius for circumference 100 is 15.915

Swift supports adding code to observe changes to a stored (but not computed) property. To do so, you add a willSet or didSet block (or both) to the property definition. These blocks are called whenever the property value is being set, even if the new and old values are the same, except when the property is being initialized. The willSet block is called before the new value is assigned to the property, and didSet is called after the assignment. A typical use for a property observer is to ensure that the property can be assigned only valid values. Here’s how you would modify the radius property in CircleClass to make sure that only non-negative values can be assigned:

class CircleClass {
    var radius: Double = 1 {
        didSet {
            if (radius < 0) {
                radius = oldValue
            }
        }
    }

When the didSet block is called, the new value has already been stored in the radius property. If it’s negative, you set it back to the previous value, which you can get from the oldValue variable. As with property setter blocks, you can change the name of this variable if you want. Setting the property value from within the didSet block does not cause the property observer blocks to be invoked again. With this change, an attempt to set a negative radius is ignored.

circleClass.radius = 10    // Valid: radius set to 10
circleClass.radius         // Result: 10.0
circleClass.radius = -1    // Invalid - trapped by didSet block
circleClass.radius         // Result: 10.0

Methods

As you have seen, classes and structures can both have methods. Methods behave just like functions, except that they have access to an implicitly defined value called self that refers to the instance of the class or structure on which the method was invoked. Methods defined on a class can change the value of its properties, but by default, structure methods cannot. Let’s see how this works adding a new method to CircleClass called adjustRadiusByAmount(_:times:) , which adjusts the circle’s radius by a given amount a specified number of times. Here’s the method definition:

func adjustRadiusByAmount(amount: Double, times: Int = 1) {
    radius += amount * Double(times)
}

With this definition, you call this method as follows:

var circleClass = CircleClass(radius: 10)
circleClass.radius                       // Result: 10
circleClass.adjustRadiusByAmount(5, times: 3)
circleClass.radius                      // Result = 10 + 3 * 5 = 25
circleClass.adjustRadiusByAmount(5)     // "times" is defaulted to 1
circleClass.radius                      // Result = 30

Now try to add the same method to the CircleStruct structure.

struct CircleStruct {
    var radius: Double = 1


    init() {
    }


    init(radius: Double) {
        self.radius = radius
    }


    func getArea() -> Double {
        return Doule.pi * radius * radius
    }


    func getCircumference() -> Double {
        return 2 * Doule.pi * radius
    }


    func adjustRadiusByAmount(amount: Double, times: Int = 1) {
        radius += amount * Double(times)
    }
}

Unfortunately, this does not compile. By default, structure methods cannot mutate the structure’s state. This is because you are encouraged to make value objects immutable, if possible. If you really want to add a mutating method like this one, you have to add the mutating keyword to its definition.

mutating func adjustRadiusBy(amount: Double, times: Int = 1) {
    radius += amount * Double(times)
}

Optional Chaining

How do you call a method or access a property of an optional? You first have to unwrap the optional. You need to be very careful when doing this because, as you already know, unwrapping an optional that is nil causes your application to crash. Suppose you have the following variable and you want to get the radius of whatever circle it’s pointing at:

var optionalCircle: CircleClass?

Since the value of optionalCircle could be nil (and, in this case, it is), you can’t just do this:

optionalCircle!.radius      // CRASH!

Instead, you need to check whether optionalCircle is nil before unwrapping it, like this:

if optionalCircle != nil {
    optionalCircle!.radius
}

This is safe, but it’s really too much code. There’s a better way, which is called optional chaining . Instead of using ! to unwrap the optional, you use ? . Using optional chaining, you can go back to writing just one line of code.

var optionalCircle: CircleClass?
var radius = optionalCircle?.radius

When optional chaining is in use, the property access occurs only if optionalCircle is not nil , and since there may be no value to assign to the radius variable, Swift infers its type as Double? instead of Double . It’s common to use this technique in conjunction with the if let construction, like this:

var optionalCircle: CircleClass?
if let radius = optionalCircle?.radius {
    print("radius = (radius)")
}

The real value of this comes if you have objects embedded in other objects, where the references to the embedded objects are optionals. To follow the chain of objects to the value that you want, you would have had to make a nil check for each reference. With optional chaining, you can let Swift do the hard work for you by using an expression like this:

outerObject?.innerObject?.property

Optional chaining also works for method calls:

var optionalCircle: CircleClass?
optionalCircle?.adjustRadiusByAmount(5, times: 3)

The method call happens only if optionalCircle is not nil ; if it is nil , the call is skipped.

Subclassing and Inheritance

So you’ve got a fairly useful class that represents a circle. What if you wanted to add something new to it? For example, let’s say you want to add a color property . Well, you would just add the property to the existing class definition and you’re done. But what if you don’t own the CircleClass class? Maybe it’s part of a third-party framework. You can’t modify the source code. In many cases like this, you might be able to add an extension to the class. Extensions let you add functionality to any class—even classes that you don’t own, and sometimes that’s the right thing to do. In this case, though, it’s not the right thing because you want to add a stored property. Instead, you’ll extend the class by creating a subclass . Subclasses inherit the properties and methods of the class from which they are derived (their base class ). If what the subclass provides isn’t quite right, you can override its behavior, keeping what you want and changing what you need to (subject, of course, to the base class being properly designed).

In this section, you’re going to extend CircleClass and create ColoredCircleClass. ColoredCircleClass will have the same features as CircleClass —it will still have the radius , area , and circumference properties—and it will have a new color property. Before you get started on that, let’s add a few more things to CircleClass so that you can see how to override them in a derived class.

Clear everything from your playground and enter the following modified definition of CircleClass :

class CircleClass {
    var radius: Double = 1 {
        didSet {
            if (radius < 0) {
                radius = oldValue
            }
        }
    }
    var area: Double {
        get {
            return M Doule.pi * radius * radius
        }


        set {
            radius = sqrt(newValue/ Doule.pi)
        }
    }


    var circumference: Double {
        get {
            return 2 * Doule.pi * radius
        }
        set {
            radius = newValue/(2 * Doule.pi)
        }
    }


    var description: String {
        return "Circle of radius (radius)"
    }


    required init() {
    }


    init(radius: Double) {
        self.radius = radius
    }


    func adjustRadiusByAmount(amount: Double, times: Int = 1) {
        radius += amount * Double(times)
    }


    func reset() {
        radius = 1;
    }
}

First, you added a computed description property that just returns a description of the class in string form. It’s a computed property because you want the return value to contain the current radius, which can change. In your ColoredCircleClass , you’ll want to add the circle’s color to this description and, as you’ll see, you’ll do so by overriding the version of the property.

Next, you added the keyword required to the initializer with no arguments. It’s very useful to have an initializer like this one that sets every property to a default value. The designer of this class thought it was so useful that he wanted to ensure that any subclass that’s created from it also provides such an initializer. Adding required to the initializer achieves that because the Swift compiler will ensure that subclasses also implement an init() initializer; furthermore, it will ensure that it’s also marked as required so that subclasses of the subclass have the same obligation. In ColoredCircleClass , you’ll set a default color in your version of this initializer.

Finally, you added a reset() method that reverts the radius property to its default value. You’ll need to override this in your subclass to also reset the circle’s new color property.

You know what you have to do. Let’s do it. As you read through what follows, add the new code to your playground. As you go along, you will encounter errors and warnings; don’t worry about those because you’ll fix them as you go along.

First, you need to create your subclass and tell the Swift compiler that its base class is CircleClass . Here’s how you do that:

class ColoredCircleClass : CircleClass {
}

This is the normal way to start a class definition, which tells Swift that ColoredCircleClass has CircleClass as its base class. Any class can have exactly one base class , which must be declared in this way. As you’ll see soon, it can also claim conformance to one or more protocols , which would also be listed here.

Next, you add the new stored property.

class ColoredCircleClass : CircleClass {
    var color: UIColor = UIColor.black
}

The type of your property is UIColor —a class from the UIKit framework that represents a color. You’ve initialized the property to a UIColor instance that represents black. Next, let’s override the description property to add your color to the returned string. Here’s how you do that:

class ColoredCircleClass : CircleClass {
    var color: UIColor = UIColor.black


    override var description: String {
        return super.description + ", color (color)"
    }
}

The first thing to notice is the override keyword, which tells the compiler that you are aware that there is already a definition of a description property in the base class and you are intentionally overriding it. In some languages, it’s very easy to accidentally create a method or a property of the same name as something in the base class without realizing it. That can lead to bugs that are hard to find.

The new implementation of this property first calls the base class version using the expression super.description . The keyword super tells the compiler that you want to reference the description property of your superclass (the one from which you are derived), not your own. Having done that, it then adds a string representation of your color property. The result will be that the description will include both the radius (from the super class) and the color (from this class).

Moving on, you need to add the required override of the init() initializer. Here it is:

required init() {
    super.init()
}

Every initializer is required to ensure that all the properties of its own class are initialized and then ensure that its base class does the same. You have only the color property, and it is initialized at the point of declaration. So, all you have to do is give the base class an opportunity to initialize its own state, which you do by calling super.init() . If you had any other properties that you needed to initialize, the compiler requires you to set them before calling super.init() . Also, note the required keyword, which is necessary because the base class init() is marked as required .

Note

I said earlier that marking the base class init() initializer as required makes it mandatory for any subclass to implement the same initializer. Up to this point, your ColoredCircleClass did not have an explicit init() initializer, yet there was no error. Why? The reason is that since ColoredCircleClass has no other initializers, the compiler created the init() initializer for you, which satisfies the base class requirement.

Next, you need an initializer that sets nondefault radius and color values. Add the following code to the class:

init(radius: Double, color: UIColor) {
    self.color = color
    super.init(radius: radius)
}

You first set the value of your Color property from the initializer argument, and then you pass the radius value to the initializer of the base class. That’s all you need to do.

The last thing you need to do is override the reset() method to reset the color property to black. By now, you should be familiar with what’s required.

override func reset() {
    super.reset()
    color = UIColor.black
}

As before, the override key tells the compiler that you are overriding a method from the base class (by the way, if you mistyped the name and called it, say, resets , the compiler would complain that there is no such method in the base class; that’s another benefit you get from the override keyword). The rest of this method follows the pattern you’ve seen before; do your part of the work—and delegate to the base class to do its part using the super keyword to invoke the base class method. Here, it doesn’t matter whether you do your part first or call the base class method first. In other words, this version would also work:

override func reset() {
    color = UIColor.black
    super.reset()
}

That’s it. Let’s try the default initializer:

var coloredCircle = ColoredCircleClass()
coloredCircle.radius          // Result: 1
coloredCircle.color           // Result: black
coloredCircle.description
       // Result: "Circle of radius 1.0, color UIDeviceWhiteColorSpace 0 1"

Now let’s try the other initializer:

coloredCircle = ColoredCircleClass(radius: 20, color: UIColor.red())
coloredCircle.radius       // Result: 20
coloredCircle.color        // Result: red
coloredCircle.description  // Result: "Circle of radius 20.0, color UIDeviceRGBColorSpace 1 0 0 1"

Subclassing is a very useful technique . Every example that you see in this book will use at least one subclass! It’s worth taking the time to review the “Initialization” and “Inheritance” sections in Apple’s Swift Programming Language book. There are a lot of subtle details that I didn’t have time to cover here.

Protocols

A protocol is the declaration of a group of methods, initializers, and properties to which a class, structure, or enumeration can conform by providing implementations of them. As you’ll see throughout this book, protocols are frequently used to define objects known as delegates , which provide hooks that allow you to customize the behavior of framework classes, react to events, and so forth.

Here’s the definition of a protocol called Resizable :

protocol Resizable {
    var width: Float { get set }
    var height: Float { get set }


    init(width: Float, height: Float)
    func resizeBy( wFactor: Float, hFactor: Float) -> Void
}

The Resizable protocol requires any type that claims conformance to it to provide the two properties, one initializer, and one function that it declares. Notice that the protocol itself does not define anything; it simply dictates what a conforming type must do. Here’s a class called Rectangle that conforms to the Resizable protocol:

class Rectangle : Resizable, CustomStringConvertible {
    var width: Float
    var height: Float
    var description: String {
        return "Rectangle, width (width), height (height)"
    }


    required init(width: Float, height: Float) {
        self.width = width
        self.height = height
    }


    func resizeBy( wFactor: Float, hFactor: Float) -> Void {
        width *= wFactor
        height *= hFactor
    }
}

A type declares that it conforms to a protocol by including the protocol name after the name of its base class, if any, in its declaration. This class conforms to both the Resizable protocol and the CustomStringConvertible protocol, which is defined in the Swift standard library.

As you can see, the class provides the actual implementation of the features required by the Resizable protocol. If a protocol requires the implementation of an initializer, then that initializer must be marked as required , as shown here. Instances of types that conform to a protocol can be assigned to variables of the protocol’s type, like this:

let r: Resizable = Rectangle(width: 10, height: 20)

Conformance to the CustomStringConvertible protocol requires the type to provide a String property called description , which is used when a human-readable representation of the type is required. In particular, this property is used when an instance of the conforming type is passed as an argument to the print() function .

let rect = Rectangle(width: 10, height: 20)
print(rect)    // Prints "Rectangle, width 10.0, height 20.0"

Extensions

Extensions are a powerful feature that Swift shares with Objective-C. An extension allows you to add functionality to any class, structure, or enumeration, including those in the standard Swift library or the system frameworks. The syntax of an extension definition is similar to that of classes and structures. The extension is introduced by the keyword extension followed by the name of the extended type and then the extensions themselves. You can add computed (but not stored) properties, methods, initializers, nested types, and protocol conformance to the extended type.

In Chapter 14 , you used an extension to add a method to the UIColor class (from the UIKit framework) that returns a random color. Here’s how the extension is defined:

extension UIColor {
    class func randomColor() -> UIColor {
        let red = CGFloat(Double((arc4random() % 256))/255)
        let green = CGFloat(Double(arc4random() % 256)/255)
        let blue = CGFloat(Double(arc4random() % 256)/255)
        return UIColor(red: red, green: green, blue: blue, alpha:1.0)
    }
}

Here’s how it’s used:

                      let randomColor = UIColor.randomColor()                                                                                                                

Summary

Now you’ve had a tour of the most important features of Swift. What you’ve seen here is by no means everything there is to know. I’ve left out quite a lot (and simplified some of the rest), and you should read the official documentation (or one of the books listed in Chapter 1 ) to expand your knowledge, when you have the time. In the meantime, turn back to Chapter 3 (or where you left off in the main part of this book) and start writing your first iOS application with Swift.

Index

A

  1. Accessory icons

  2. Action methods

    1. definition

    2. sender

    3. user interface

  3. Adaptive layouts

    1. restructure

SeeRestructure application, iPhone
  1. wC hC configuration

SeewC hC landscape configuration
  1. wR hR configurations, setting iPad

  1. AppIcon

  2. Apple Developer Program

  3. Application delegate

    1. implementation of

    2. links

    3. UIApplicationDelegate

  4. Application programming interfaces (APIs)

  5. applicationWillEnterForeground() method

  6. applicationWillResignActive() method

  7. Auto Layout

    1. align button

    2. constraints

    3. fix frame

    4. Interface Builder

    5. Pin button

    6. pop-up

    7. problems

    8. run application

    9. View icon

    10. warnings

  8. Automatic Reference Counting (ARC)

B

  1. Backing store

  2. Base of stack

  3. Bind variables

  4. Booleans

  5. Bridge Control application

    1. adding multivalue field

    2. adding secure text field setting

    3. changing defaults

    4. child settings view

    5. creating the project

    6. keeping real

    7. reading settings

    8. registering default values

    9. retrieving user settings

    10. settings bundle to project

    11. slider setting, adding

    12. switching to settings application

    13. text field setting

    14. Toggle switch setting, adding

    15. working with settings bundle

  6. ButtonFun app

    1. actions

SeeAction methods
  1. Auto Layout

  2. change text style

  3. creating

  4. in iPhone models

  5. label and outlet

    1. Attributes Inspector

    2. Object Library

    3. UILabel outlet

  6. outlets

  7. previewing layout

  8. UIViewController

  9. user interface

    1. action method

    2. Assistant Editor

    3. buttonPressed() method

    4. floating pop-up

    5. Main.storyboard

    6. Object Library

  10. ViewController

  1. buttonPressed() method

C

  1. cellPointSize property

  2. Clock application

  3. Coalescing operator

  4. Cocoa

  5. Cocoa Touch applications

    1. MVC

  6. Code-compile-debug cycle

  7. Code Snippet Library

  8. Collection views, DialogViewer Project

    1. content cells

    2. custom cells

    3. header views

    4. layout flow

    5. UICollectionView

    6. UICollectionViewController

    7. UICollectionViewFlowLayout

    8. view controller configuration

    9. ViewController.swift

  9. Color model

  10. Color space

  11. configureView() method

  12. Container view controllers

  13. Control Fun application

D, E

  1. dataFilePath() method

  2. Data source methods

  3. Device rotations

    1. adding Auto Layout

    2. autorotation

    3. constraints

    4. landscape mode

    5. layout

      1. add labels to storyboard

      2. change orientation

      3. container view

      4. Document Outline view

      5. Interface Builder

      6. left label

      7. Size Inspector

      8. solid blue lines

      9. top labels

      10. UL label

    6. orientations

      1. active view controller

      2. Info.plist file

      3. Boolean OR operator

      4. select application orientations

      5. setting portrait label

      6. UIKit

    7. points

    8. view controller

  4. didReceiveMemoryWarning() method

  5. dwarves array

F

  1. fetch() method

  2. Fetched property

  3. File Template Library

  4. FontInfoViewController

  5. FontListViewController

  6. FontSizesViewController

G

  1. Gamut

  2. Globally unique identifiers (GUIDs)

  3. GNU Compiler Collection (GCC)

  4. Graphics and drawing

    1. Quartz 2D

      1. bit of color theory

      2. color models

      3. contexts

      4. coordinate system

      5. drawing code

      6. images in context

      7. shapes

      8. specifying colors

      9. tool sampler

    2. QuartzFun application

      1. action methods

      2. creating

      3. optimizing

      4. outlets and actions

      5. QuartzFunView skeleton

      6. random color

      7. shape and color enumerations, defining

  5. Grouped table

H

  1. Hello World Project

    1. asset catalog

    2. Hello WorldTests

    3. on home screen

    4. products

    5. Xcode project window

      1. integrated compiler and debugger

      2. Interface Builder (IB)

      3. jump bar

      4. navigator

      5. toolbar

      6. utilities area

  2. Historical subtractive primaries

  3. Human Interface Guidelines (HIG)

I, J, K

  1. Image view and text fields

    1. action method

    2. action sheet and alert

    3. adding

    4. adding button

    5. adding image to the button

    6. alert, presenting

    7. alpha value

    8. attributes for second text field

    9. constraints, adding

    10. control states

    11. displaying action sheet

    12. drawing check boxes

    13. inspector settings

    14. interaction check boxes

    15. keyboard, closing

      1. touching the background

    16. labeled switches

    17. Mode attribute

    18. outlets and actions

      1. button

      2. connecting

    19. resizing

    20. segmented control action

    21. Semantic attribute

    22. setting view attributes

    23. slider and label

    24. stretchable images

    25. stretching

    26. switch actions

    27. switches, button, and segmented control

    28. using Background

    29. using Tag

    30. using tint

  2. Implicitly unwrapped optionals

  3. Indent level

  4. Initializer

  5. insertNewObject()method

  6. Integrated development environment (IDE)

  7. Interface Builder (IB)

    1. changing attributes

    2. exploring storyboard

    3. file formats

    4. label to the view

    5. utilities area, exploring

  8. Interface controls

  9. Interface orientation

  10. iOS 8

  11. iOS interfaces, fonts

  12. iOS landscape

    1. Apple Developer Forums

    2. apps response

    3. developer

    4. features

    5. limited device resources

    6. limited screen size

    7. security, access to device resources

    8. single window

    9. supports single application

    10. Swift and Xcode versions

    11. user input and display

    12. working in

  13. iOS User Defaults mechanism

  14. iPad

    1. setting up landscape orientations

    2. wR hR configurations

  15. iPad apps

    1. AppDelegate.swift

    2. Connections Inspector

    3. detail view controller

    4. Interface Builder

    5. master-detail application

    6. MasterViewController

    7. MasterViewController.swift

    8. popover controller/popover

    9. president data

    10. split view

    11. UISplitViewController

    12. view controllers

  16. iPhone Plus landscape orientation

L

  1. LanguageListController class

  2. Launch screen

  3. Lazy loading

  4. Low Level Virtual Machine (LLVM) compiler

M

  1. Managed object context

  2. Master-detail applications

  3. Media library

  4. Model-view-controller (MVC)

  5. Multiview application

    1. architecture of

      1. content view anatomy

      2. root controller

    2. navigation bar

    3. tab bar

    4. types of

    5. UITabBarController class

    6. View Switcher application

      1. animating transition

      2. content view controllers

      3. content views, implementing

      4. modifying SwitchingViewController.swift

      5. root view controller implementation

      6. toolbar

      7. toolbar button to view controller

      8. view controller, renaming

  6. MVC

SeeModel-view-controller (MVC)

N

  1. Navigation controllers

    1. accessory icons

    2. advantages

    3. drag-to-reorder implementation

    4. favorite fonts

    5. font info view controller storyboard

    6. font list controller

    7. font list storyboard

    8. font list view

    9. Fonts App

    10. fonts application’s skeleton

    11. font sizes view controller

    12. initial storyboard setup

    13. multiple segues

    14. root view controller

    15. settings

    16. setting up constraints

    17. stack

    18. stack of controllers

    19. swipe-to-delete implementation

    20. UINavigationController

    21. UITabBarController

  2. Nib file

  3. numberOfSectionsInTableView() method

O

  1. Object Library

  2. onButtonPressed() method

  3. onEngineSwitchTapped() method

  4. onSettingsButtonTapped() method

  5. onWarpSliderDragged() method

  6. Optional chaining

P

  1. Painter’s model

  2. Persistence

    1. application’s sandbox

      1. documents and library directories

      2. tmp directory

    2. archiving model objects

      1. archiving and unarchiving data objects

      2. archiving application

      3. bind variables, using

      4. creating/opening database

      5. FourLines class

      6. iOS’s embedded SQLite3

      7. NSCoding protocol

      8. NSCopying

      9. ViewController class

    3. Core Data

      1. AppDelegate.swift file, modifying

      2. designing data model

      3. entities and managed objects

      4. key-value coding

      5. new managed objects

      6. Persistence view

      7. retrieving managed objects

      8. stores

    4. file-saving strategies

      1. multiple-file persistence

      2. single-file persistence

    5. property lists

      1. application view

      2. first version

      3. persistence classes, editing

      4. serialization

    6. SQLite3 application

      1. linking

      2. view controller

    7. store

  3. Plain tables

  4. Pop (stack)

  5. Property

  6. Push (stack)

  7. Pythagoras’s theorem

Q

  1. Quartz 2D

    1. bit of color theory

    2. color models

    3. coordinate system

    4. drawing code

    5. graphics contexts

    6. images in context

    7. shapes

    8. specifying colors

    9. tool sampler

R

  1. Raw value

  2. refreshFields() method

  3. registerDefaults() method

  4. register() method

  5. Restructure application, iPhone

    1. add constraints

    2. Auto Layout constraints

    3. Control-dragging

    4. Document Outline

    5. green view

    6. initial GUI

    7. iPad Air

    8. iPhone 6s orientations

    9. Object Library

    10. select orientation

    11. set equal width

    12. set height value

    13. set left edge

    14. set vertical spacing

  6. RGBA color model

  7. Root controller

  8. Root view controller

  9. RootViewController.swift file

  10. RYB color model

S

  1. Serialized object

  2. setNeedsDisplayInRect() method

  3. Settings bundle

    1. Bridge Control application.

SeeBridge Control application
  1. Single View App

  2. sizeToFit() method

  3. Software development kit (SDK)

    1. versions and source code

  4. Source control management (SCM) tools

  5. SQLite3 application

  6. Stored property

  7. stride() method

  8. Strings

  9. Subcontrollers

  10. supportedInterfaceOrientations() method

  11. Supported interface orientations

  12. Swap file

  13. Swift

    1. arrays and ranges

    2. basics

    3. classes

    4. control statements

      1. for statement

      2. functions and closures

      3. if statement

      4. repeat and while statements

      5. switch statement

    5. dictionaries

    6. error handling

      1. catching errors

      2. guard statement

      3. throwing error

    7. extensions

    8. methods

    9. NSArray, NSDictionary, and NSSet

    10. optional chaining

    11. optionals

    12. playgrounds, comments, variables, and constants

    13. predefined types, operators, and control statements

      1. Booleans

      2. enumerations

      3. numeric types

      4. strings

    14. properties

    15. protocols

    16. sets

    17. structures

    18. subclassing and inheritance

  14. synchronize() method

T

  1. Tab bar applications and pickers

    1. application

    2. custom picker

      1. adding details for game

      2. building the view

      3. controller, implementing

      4. preparing view controller

      5. spin() method

      6. viewDidLoad() method

    3. custom picker with images

    4. date picker

    5. delegates and data sources

    6. with dependent components

    7. initial simulator test

    8. multicomponent picker

      1. building the view

      2. controller, implementing

      3. dependent components, implementing

    9. single-component picker

      1. building the view

      2. data source and delegate

    10. tab bar controllers

    11. view controllers

  2. Table views

    1. add subviews

    2. clock application

    3. controller code

    4. create UITableViewCell subclass

    5. init() method

    6. mail application

    7. sections

      1. add index

      2. add search bar

      3. create

      4. data source methods

      5. filter() method

      6. grouped table

      7. plain table

      8. scope buttons

      9. search results code

      10. sizeToFit() method

      11. sortednames.plist

      12. viewDidLoad() method

      13. view hierarchy

    8. simple table

      1. add image

      2. change font size

      3. change row heights

      4. class declaration

      5. dataSource methods

      6. detail text label

      7. dwarves array

      8. indent level

      9. optional chaining

      10. pinning

      11. row selection

      12. subtitle style

    9. viewDidLoad() method

    10. XIB file

  3. Text label

U

  1. UICollectionFlowLayout method

  2. UICollectionViewCell class

  3. UICollectionViewLayout

  4. UIInterfaceOrientationMask

  5. UIKit framework

  6. UIPickerViewDataSource protocol

  7. UIStoryboardSegue class

  8. UITableViewController

  9. UIViewController method

  10. UserDefaults (NSUserDefaults) class

V

  1. ViewController.swift file

  2. viewDidLoad() method

  3. viewWillAppear() method

W

  1. wC hC landscape configuration

    1. change device type

    2. configuring buttons

    3. create iPhone landscape orientation

    4. create master copy

    5. Done Varying button

    6. green view

    7. save baseline project

    8. UI elements

  2. wordsInSection() method

  3. wR hR configurations, setting iPad

    1. setting up all orientations

    2. setting up landscape orientations

X, Y, Z

  1. Xcode

    1. Interface Builder

SeeInterface Builder (IB)
  1. keyboard shortcuts

  2. launching

  3. // MARK

  4. property

  5. running application on device

  6. user interface (UI)

  7. welcome window

  1. XIB file

    1. add Auto Layout

    2. Attributes Inspector

    3. content view

    4. create UI file

    5. custom class

    6. File’s Owner

    7. load UITableViewCell

    8. middle cell

    9. outlets

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.238.82.77