Constants and variables associate an identifier (such as myName or currentTemperature) with a value of a particular type (such as the String or Integer type), where the identifier can be used to retrieve the value. The difference between a constant and a variable is that a variable can be updated or changed, while a constant cannot be changed once a value is assigned to it.

Constants are good for defining values that you know will never change, like the temperature that water freezes at or the speed of light. Constants are also good for defining a value that we use many times throughout our application, such as a standard font size or the maximum number of characters in a buffer. There will be numerous examples of constants throughout this book, and it is recommended that we use constants rather than variables whenever possible.

Variables tend to be more...

Swift contains many of the standard numeric types that are suitable for storing various integer and floating-point values. Let's start off by looking at the integer type.

An integer is a whole number and can be either signed (positive, negative, or zero) or unsigned (positive or zero). Swift provides several integer types of different sizes. The following chart shows the value ranges for the different integer types on a 64-bit system:

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

Boolean constants and variables can be defined like this:

let swiftIsCool = true  
var itIsRaining = false 

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

let isSwiftCool = true  
let isItRaining = false  
if isSwiftCool { 
print("YEA, I cannot wait to learn it") 
} 
if isItRaining {  
print("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. This line is printed out because the isSwiftCool Boolean type is set to true. As the isItRaining variable...

A string is an ordered collection of characters, such as Hello or Swift, and is represented by the String type. We have seen several examples of strings in this book, and therefore the following code should look familiar. This code shows how to define two strings:

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

We can also create a string using a multiline string literal. The following code shows how we can do that:

var multiLine = """ 
This is a multiline string literal.  
This shows how we can create a string over multiple lines. 
""" 

Notice that we put three double quotes around the multiline string. We can use quotes in our multiline string to quote specific text. The following code shows how to do this:

var multiLine = """ 
This is a multiline string literal.  
This shows how we can create...

Tuples group multiple values into a single compound type. These values are not required to be of the same type.

The following example shows how to define a tuple:

var team = ("Boston", "Red Sox", 97, 65, 59.9) 

In the preceding example, an unnamed tuple was created that contains two strings, two integers, and one double. The values of the tuple can be decomposed into a set of variables, as shown in the following example:

var team = ("Boston", "Red Sox", 97, 65, 59.9)  
var (city, name, wins, losses, percent) = team 

In the preceding code, the city variable will contain Boston, the name variable will contain Red Sox, the wins variable will contain 97, the losses variable will contain 65, and finally the percent variable will contain 59.9.

The values of the tuple can also be retrieved by specifying the location of the value. The following...

Enumerations (also known as enums) are a special data type that enables us to group related types together and use them in a type-safe manner. Enumerations in Swift are not tied to integer values as they are in other languages, such as C or Java. In Swift, we are able to define an enumeration with a type (string, character, integer, or floating-point) and then define its actual value (known as the raw value). Enumerations also support features that are traditionally only supported by classes, such as computed properties and instance methods. We will discuss these advanced features in depth in Chapter 7, Classes, Structures, and Protocols. In this section, we will look at the traditional features of enumerations.

We will define an enumeration that contains a list of Planets, like this:

enum Planets {  
  case mercury  
  case venus  
  case earth  
  case mars  
 ...

An operator is a symbol or combination of symbols that we can use to check, change, or combine values. We have used operators in most of the examples so far in this book, but we did not specifically call them operators. In this section, we will show you how to use most of the basic operators that Swift supports.

Swift supports most standard C operators and also improves on some of them to eliminate several common coding errors. For example, the assignment operator does not return a value, which prevents it from being used where we are meant to use the equality operator, which is two equal signs (==).

Let's look at the operators in Swift.

The assignment operator initializes or updates a variable...

In this chapter, we covered topics ranging from variables and constants to data types and operators. The items in this chapter will act as the foundation for every application that you write; therefore, it is important to understand the concepts we discussed here.

In this chapter, we have seen that we should prefer constants to variables when the value is not going to change. Swift will give you a compile time warning if you set but never change a variable's value. We also saw that we should prefer type inference over declaring a type.

Numeric and string types, which are implemented as primitives in other languages, are named types that are implemented with structures in Swift. In future chapters, you will see why this is important. One of the most important things to remember from this chapter is that, if a variable contains a nil value, you must declare it as an...