Beginning Swift

When learning a new language, it's traditional for a first program to make sure the development environment is installed and properly configured by writing a program that outputs something to the screen. That's what we'll do next.

Now, let's use an Xcode playground to create a simple Swift program to display the string Hello, World to the playground console, by following these steps:

Congratulations! You've just written your first Swift program. If you see the text Hello, World. output in the bottom pane of the playground window, your program has worked.

Before we move on, let's look at the structure of the playground window:

Note the following regions in the playground window, as indicated by the numbers within the red circles:

Now that we have a development environment up and running where we can create and run Swift code, let's move on to learning about and using the Swift language.

A Swift variable declaration uses the following basic syntax:

var <variable name> : <type> = <value>

Given this syntax, a legal declaration for a Pi variable would be the following:

                        var pi : Double = 3.14159

This declaration means: create a variable named Pi , which stores a Double data type, and assign it an initial value of 3.14159.

You may want to store a named value in your program that will not change during the life of the program. In the previous example, the value of Pi should never change during the course of a program. How can we ensure that, once defined, this named value can never be accidentally changed by our code?

Swift variables are declared using the var keyword, while Swift constants are declared using the let keyword, for example:

var pi1 = 3.14159
let pi2 = 3.15159

In this code, the named value pi1 is a variable, and its value can be changed by the code after it is declared. The following line of code later in the program would be legal, even though it would result in an invalid value for pi1:

pi1 = pi1 * 2.0

On the other hand, since pi2 was declared as a constant, using the let keyword, the following line of code later in the program would result in a compile-time error, since changing a let constant is illegal:

pi2 = pi2 * 2.0

Generally, any time you create a named value that will never be changed during the run of your program, you should use the let keyword to create a constant. The Swift compiler enforces this recommendation by creating a compile-time warning whenever a var is created that is not subsequently changed.

In the previous example, we created the variable pi1 without specifying its data type. We took advantage of a Swift compiler feature called type inference.

When you assign the value of a variable or constant as you create it, the Swift compiler will analyze the right-hand side of the assignment, infer the data type, and assign that data type to the variable or constant you're creating. For example, in the following declaration, the compiler will create the variable name as a String data type:

var name = "George Smith"

As a type-safe language, once a data type is inferred by the compiler, it remains fixed for the life of the variable or constant. Attempting to assign a non-string value to the name variable declared above would result in a compile-time error:

name = 3.14159  // Error: "Cannot assign value of type 'Double' to 'String'

While Swift is a type-safe language, where variable types are explicit and do not change, it is possible to create Swift code that behaves like a dynamic type language using the Swift Any data type. For example, the following code is legal in Swift:

var anyType: Any
anyType = "Hello, world"
anyType = 3.14159

While this is legal, it's not a good Swift programming practice. The Any type is mainly provided to allow bridging between Objective-C and Swift code. To keep your code as safe and error-free as possible, you should use explicit types wherever possible.

Swift variables and constants have the same naming rules as most C-inspired programming languages:

When creating variable and constant names in Swift, the generally accepted naming convention is to use a camelCase naming convention, beginning with a lowercase letter. Following generally accepted naming conventions makes code easier for others to read and understand (https://swift.org/documentation/api-design-guidelines/#follow-case-conventions).

For example, the following would be a conventional variable declaration:

var postalCode = "48108"

However, the following would not be conventional, and would be considered incorrect by many other Swift developers:

var PostalCode = "48108"
var postal_code  = "48108"
var POSTALCODE = "48108"

Unlike many other programming languages, Swift is not restricted to the Western alphabet for its variable name characters. You may use any Unicode character as part of your variable declarations. The following variable declarations are legal in Swift:

var helloWorld = "Hello, World"
var 你好世界 = "Hello World"
var 😊 = "Smile!"

One of Swift's unique language features is its inclusion of tuples. By default, variables and constants store a single value. Tuples allow a variable or constant name to refer to a set of values. While tuples do not exist in many languages, you can think of them as compound values, and they function almost identically to a structure, which is a single named object which can store more than one variable embedded within it.

By using a tuple, we could take the following variable declaration:

var dialCode = 44
var isoCode = "GB"
var name = "United Kingdom"

We could combine it to the following:

var country = (44, "GB", "United Kingdom")

Then we can access the individual members of the tuple as follows:

print(country.0)  // outputs 44
print(country.1)  // outputs GB
print(country.2)  // outputs United Kingdom

Tuple members can also be given individual names, as follows:

var country = (dialCode: 44, isoCode: "GB", name: "Great Britain")

print(country.dialCode)  // outputs 44
print(country.0)              // also outputs 44!
print(country.isoCode)   // outputs GB
print(country.name)       // outputs United Kingdom

Swift functions can accept multiple input parameters, but return only one value. A common use case for a tuple variable type is to include more than one value from a function:

func getCountry() -> (dialCode: Int, isoCode: String, name: String) {
    let country = (dialCode: 44, isoCode: "GB", name: "United Kingdom")
    return country
}

let ret = getCountry()

print(ret)

A second way to return multiple values from a function is to use inout parameters, which allows a function to change the value of an input parameter within that function.

While there are valid use cases for changing inout parameter values, returning a tuple has the advantage of returning a value type—rather than modifying input values.

Another unique language feature Swift provides is the optional. In most programming languages, all variables and constants must hold some value. But, in the real world, sometimes a value is unknown. For example, an address may or may not contain a second address line, and more than 60 countries in the world don't use postal codes. Optionals allow variables to indicate whether their value is missing (that is, not assigned), or is truly a  blank value.

Optionality for Swift variables is optional (pun intended). To declare a variable as an optional, add a question mark (?) to the end of its data type (or assign another optional variable's value to it so the optional property is inferred from the existing variable).

The following variable name is not an optional:

var name: String = "Hello"

This next variable name is an optional, and has an initial value of nil:

var name: String?

The presence of the question mark intuitively expresses that the variable may—or may not—contain a string. If the optional is not assigned a value, it will automatically be set to nil, meaning it has no value.

var customerAge: Int!

var name: String?

var nameCopy = name

name = "Adam Smith"

var a: Int? = 4
a = nil
if a == nil {
  print("a is nil")
}

var a: Int?
var b: Int = 4

b = a

Value of optional type 'Int?' not unwrapped; did you mean to use '!' or '?'?

b = a!

Fatal error: Unexpectedly found nil while unwrapping an Optional value

var a: Int? = 2
var b: Int = 4
b = a!

var a: Int? = 4
if let b = a {
   print(b)
}

func doubleValue(input: Int?) -> Int? {
   if let i = input {
      return i * 2
   }
   return nil
}

func doubleValue(input: Int?) -> Int? {
   guard let i = input else { return nil }
   return i * 2
}

In Swift, variables are declared before being used. Variables can be declared in various ways, and may not even need to have their type explicitly stated when the compiler can infer data type from initial assignment.

Use an Xcode playground to practice how to declare variables, constants, and tuples.

Like most programming languages, Swift provides built-in numeric data types that represent either integer or floating-point values.

let minutes = 100         // decimal
let minutes = 0b1100100   // binary
let minutes = 0o144       // octal
let minutes = 0x64        // hexadecimal

var interestRate = 5.34

var minutes = 100000
var minutes = 100_000
var minutes = 10_00_00
var minutes = 0b110_000110_101000_00

var balance = 10000.44556
var balance = 10_000.44_556

Int8 smallNumber = 3;
Int16 mediumNumber = smallNumber;

var smallNumber: Int8 = 3
var mediumNumber: Int16 = smallNumber

error: cannot convert value of type 'Int8' to specified type 'Int16'

var smallNumber: Int8 = 100
var mediumNumber: Int16 = Int16(smallNumber)

In Swift, the Boolean data type is Bool, and stores a value of true or false. As with other data types, in the case that a Bool value is not yet known, a Bool can be declared as optional, for example, Bool?.

For example, the following code declares a Boolean in Swift, and then changes its value:

var isChecked = false
isChecked = true

Testing for the value of a Bool value is similar to how we do it in other C-inspired languages, for example:

if isChecked {
   // statements to execute if isChecked is true
}
if isChecked == true {
   // statements to execute if isChecked is true
}
if !isChecked {
   // statements to execute if isChecked is false
}

The Character data type in Swift is an extended grapheme cluster.

What does that mean?

An extended grapheme cluster is an ordered sequence of one or more Unicode scalars (that is, values) that, when taken together, produce a human-readable character.

Most important to understand is that, unlike ASCII or ANSI character representations many programmers have worked with before, a Character in Swift may be made of more than one Unicode value.

In Swift 4, the underlying complexities of Unicode, scalar values, and extended grapheme clusters are largely managed for you, but as you begin to work natively with Unicode characters and strings, bear in mind that the Swift Character/String architecture was developed from the ground up around Unicode character representation—not ANSI/ASCII as many other languages were.

let ch1:Character = "A"
let ch2:Character = "😎"

let ch1 = Character(UnicodeScalar(65))

let ch3 = "\u{1F601}"  // sets ch3 to "😁"

let ch4 = "e\u{301}"   // é

Strings in Swift are very similar to strings in other programming languages. As string handling is so central to any application development project, we'll dedicate an entire subsequent lesson to Swift's powerful string handling capabilities. In this section, we'll discuss the basics for declaring and using a string.

Fundamentally, strings are arrays of the Character types, supporting the familiar assignment operator (=), substrings, concatenation, and C-inspired escape characters.

var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
let macCharacters = "⌘⌃⌥⇧ ⏎⌫⇪⎋⇥"
let emoji = "😎😂🎃🐳🍎😜😆"

let alphaMac = alphabet + macCharacters

alphabet += macCharacters

let ch = alphabet[4]
error: 'subscript' is unavailable: cannot subscript String with an Int, see the documentation comment for discussion

let idx = alphabet.index(alphabet.startIndex, offsetBy: 4)
let ch = alphabet[idx]  // ch is assigned the character "E"

var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
let alphabetLength = alphabet.count  // 26

Now that you've learned about the various data types available with Swift, let's put this knowledge into practice by using various types together, and also using the Apple Foundation framework.

Use an Xcode playground to practice various data types. You'll be using numeric data types, formatting them as strings, and using string interpolation to print string values from various data types.

Consider the following code, which creates and uses a basic enum:

enum DayOfWeek {
    case monday, tuesday, wednesday, thursday, friday
}

var today = DayOfWeek.wednesday

if today == .friday {
    print("Today is Friday")
} else {
    print("Today is not Friday")
}

Defining the enum DayOfWeek declares a new data type, which can be used just like any other data type. Because the variable today is of the type DayOfWeek, which can only be assigned one of the seven listed values, we could not assign anything else. For example, the following code would generate a compile-time error, because Saturday is not included in the predefined values:

Var today = DayOfWeek.saturday

The preceding example illustrates the two most important advantages of enums:

In the preceding enum example, the enum values (.monday, .tuesday, and so on) have no underlying data type. For example, we might want to calculate the day of week by subtracting the ordinal number for the today variable from .monday.

However, with the enum as defined, there is no numeric value associated, so the following code will fail to compile:

var nthDay = today - DayOfWeek.Monday

This code generates the following error:

Binary operator – cannot be applied to two 'DayOfWeek' operands

This is by design, because unlike some languages, a Swift enum need not be mapped to a native data type (and should not be, if there's no reason to do so).

However, Swift enums can be mapped to any underlying data type. In the following revision, we map the day of week to the Int data type, which enables the nth day of the week calculation mentioned above:

enum DayOfWeek: Int {
    case monday, tuesday, wednesday, thursday, friday
}

var today = DayOfWeek.Wednesday // DayOfWeek.wednesday
var nthDay = today.rawValue - DayOfWeek.monday.rawValue + 1 // 3
var tomorrow = DayOfWeek(rawValue: today.rawValue + 1) // DayOfWeek.thursday

In this case, all we needed to do was add a native data type (Int) to the enum declaration. The Swift compiler then holds a .rawValue property. When an enum has an underlying value, it also becomes possible to create an enum member by passing it to the rawValue: parameter of the enum initializer.

In the preceding example, we used Int as the raw value for the revised DayOfWeek enum. Swift allows any data type to serve as the underlying value of an enum. For example, we could use String instead of Int to enable the following use case:

enum DayOfWeek: String {
    case monday = "Monday"
    case tuesday = "Tuesday"
    case wednesday = "Wednesday"
    case thursday = "Thursday"
    case friday = "Friday"
    case saturday = "Saturday"
}

var today = DayOfWeek.Wednesday // DayOfWeek.wednesday
let dayString = today.rawValue  // "Wednesday"

In this section, we have looked at enums in detail. We saw its syntax and how to define an enum with raw values. We will now work through an activity where we will use enums to implement error codes.

Enumerations are a powerful construct available in many programming languages. Enumerations make code more robust and easier for others to understand and maintain.

Use Xcode to define error codes using conventional error number techniques, and alternatives that use Swift enums.