Constants and variables must be defined prior to using them. To define a constant, you use the keyword let, and to define a variable, you use the keyword var. The following are some examples of constants and variables:

// Constants
let freezingTemperatureOfWaterCelsius = 0
let speedOfLightKmSec = 300000

// Variables
var currentTemperature = 22
var currentSpeed = 55

We can declare multiple constants or variables in a single line by separating them with a comma. For example, we could shrink the preceding four lines of code down to two lines like this:

// Constants
let freezingTempertureOfWaterCelsius = 0, speedOfLightKmSec = 300000

// Variables
var currentTemperture = 22, currentSpeed = 55

We can change the value of a variable to another value of a compatible type; however, as we noted earlier, we cannot change the value of a constant. Let's look at the following Playground. Can you tell what is wrong with the code from the error message that is shown in...

Swift contains many of the standard numeric types that are suitable for storing various integer and floating-point values.

Boolean values are often referred to as logical values because they can be either true or false. Swift has a built-in Boolean type called Bool that accepts one of two built-in Boolean constants. These constants are true and false.

Boolean constants and variables can be defined like this:

let swiftIsCool = true
let swiftIsHard = false

var itIsWarm = false
var itIsRaining = true

Boolean values are especially useful when working with conditional statements, such as if and while. For example, what do you think this code would do:

let isSwiftCool = true
let isItRaining = false
if (isSwiftCool) {
    println("YEA, I cannot wait to learn it")
}

if (isItRaining) {
    println("Get a rain coat")
}

If you answered that this code would print out YEA, I cannot wait to learn it, then you would be correct. Since isSwiftCool is set to true, the YEA, I cannot wait to learn it message is printed out, but isItRaining is false; therefore, the Get a rain coat is not.

You can...

A string is an ordered collection of characters, such as Hello or Swift. In Swift, the string type represents a string. We have seen several examples of strings already in this book, so the following code should look familiar. This code shows how to define two strings:

var stringOne = "Hello"
var stringTwo = " World"

Since a string is an ordered collection of characters, we can iterate through each character of a string. The following code shows how to do this:

var stringOne = "Hello"
for char in stringOne {
  println(char)
}

The preceding code will display the results shown in the following screenshot:

There are two ways to add one string to another string. We can concatenate them or we can include them inline. To concatenate two strings, we use the + or the += operator. The following code shows how to concatenate two strings. The first example appends stringB to the end of stringA and the results are put into a new stringC variable. The second...

All of the variables that we have looked at so far are considered to be nonoptional variables. This means that the variables are required to have a non-nil value; however, there are times when we want or need our variables to contain nil values. This can occur if we return a nil from a function whose operation failed or if a value is not found.

In Swift, an optional variable is a variable that we are able to assign nil (no value) to. Optional variables and constants are defined using ? (question mark). Let's look at the following Playground; it shows us how to define Optional and shows what happens if we assign a nil value to a Non-Optional variable:

Notice the error we receive when we try to assign a nil value to the nonoptional variable. This error message tells us that the stringTwo variable does not conform to the NilLiteralConvertible protocol. What this tells us is that we are assigning a nil value to a variable or constant that is not defined as an optional...