Integers

Integers are whole numbers with no fractional parts. Integers can be positive or negative. In Swift, integers are represented using the Int type. The Int type represents both positive as well as negative values. If you only need to store positive values, you can use the unsigned integer UInt type. The size of an Int type depends on the system on which your code is running. On 32-bit systems, Int and UInt each use 32 bits for storage, whereas on 64-bit systems Int and UInt each use 64 bits.

You can programmatically check the number of bytes stored by each data type using the sizeof() function:

println("Size of Int: (sizeof(Int)) bytes")
println("Size of UInt: (sizeof(UInt)) bytes")

If you run the preceding statement on an iPhone 5 (which uses the 32-bit A6 chip), you will get the following:

Size of Int: 4 bytes
Size of UInt: 4 bytes

If you run the preceding statement on an iPhone 5s (which uses the 64-bit A7 chip), you will get the following:

Size of Int: 8 bytes
Size of UInt: 8 bytes

If you do not know the type of data a variable is storing, you can use the sizeofValue() function:

var num = 5
println("Size of num: (sizeofValue(num)) bytes")

//---UInt8 - Min: 0 Max: 255---
println("UInt8 - Min: (UInt8.min) Max: (UInt8.max)")

//---UInt16 - Min: 0 Max: 65535---
println("UInt16 - Min: (UInt16.min) Max: (UInt16.max)")

//---UInt32 - Min: 0 Max: 4294967295---
println("UInt32 - Min: (UInt32.min) Max: (UInt32.max)")

//---UInt64 - Min: 0 Max: 18446744073709551615---
println("UInt64 - Min: (UInt64.min) Max: (UInt64.max)")

//---Int8 - Min: -128 Max: 127---
println("Int8 - Min: (Int8.min) Max: (Int8.max)")

//---Int16 - Min: -32768 Max: 32767---
println("Int16 - Min: (Int16.min) Max: (Int16.max)")

//---Int32 - Min: -2147483648 Max: 2147483647---
println("Int32 - Min: (Int32.min) Max: (Int32.max)")

//---Int64 - Min: -9223372036854775808 Max: 9223372036854775807---
println("Int64 - Min: (Int64.min) Max: (Int64.max)")

var i1: UInt8 = 255
var i2: UInt16 = 255
var i3 = i1 + i2   //---cannot add two variables of different types---

var i3 = UInt16(i1) + i2 //---i3 is now UInt16---

let num1 = 15              //---decimal---
let num2 = 0b1111        //---binary
let num3 = 0o17           //---octal---
let num4 = 0xF           //---hexadecimal---

let num1 = 00000015        //---decimal---
let num2 = 0b001111        //---binary
let num3 = 0o000017        //---octal---
let num4 = 0x00000F        //---hexadecimal---

let billion = 1000000000

let billion = 1_000_000_000

let billion = 100_00_00_00_0

Floating-Point Numbers

Floating-point numbers are numbers with fractional parts. Examples of floating-point numbers are 0.0123, 2.45, and –4.521. In Swift, there are two floating-point types: Float and Double. Float uses 32 bits for storage and Double uses 64 bits. This can be confirmed using the sizeof() function:

println("Size of Double: (sizeof(Double)) bytes")
println("Size of Float: (sizeof(Float)) bytes")

Double has a precision of at least 15 decimal digits, while Float has a precision of at least six decimal digits.

When assigning a floating-point number to a constant or variable, Swift will always infer the Double type unless you explicitly specify otherwise:

var num1 = 3.14 –              //---num1 is Double---
var num2: Float = 3.14     //---num2 is Float---

If you try to assign a Double to a Float type, the compiler will flag an error:

num2 = num1     //---num1 is Double and num2 is Float---

This is because the number stored in a Double type may not be able to fit into a Float type, thereby resulting in an overflow. In order to assign num1 to num2, you need to explicitly cast num1 to a Float, like this:

num2 = Float(num1)

var sum1 = 5 + num1     //---num1 and sum1 are both Double---
var sum2 = 5 + num2     //---num2 and sum2 are both Float---

var i4: Int = 123
var f1: Double = 3.14567
var r = i4 + f1     //---error---

var r = Double(i4) + f1

var someNumber = 5 + 3.14

var f:Float
var i:Int = 5
f = i  //---error---
f = Float(i)

var floatNum = 3.5
var intNum = Int(floatNum)  //---intNum is now 3---

let num5 = 345.678
let num6 = 3.45678E2      // 3.45678 x 10^2
let num7 = 34567.8E-2     // 3.45678 x 10^(-2)

let num8 = 0x2Cp3      // 44 x 2^3
let num9 = 0x2Cp-3     // 44 x 2^(-3)

Type Alias

A type alias enables you to define an alternative name for the existing data type. For example, using the built-in types you can specify the data type for variables like this:

var customerID: UInt32
var customerName: String

However, it would be more useful if you could provide a more meaningful and contextually relevant name using the typealias keyword:

typealias CustomerIDType = UInt32
typealias CustomerNameType = String

In the preceding code snippet, CustomerIDType is now the alias for the UInt32 type, and CustomerNameType is the alias for the String type. You can use the aliases as if they are the data types, like this:

var customerID: CustomerIDType
var customerName: CustomerNameType

customerID = 12345
customerName = "Chloe Lee"

Boolean

Swift supports the Boolean logic type—Bool. A Bool type can take either a true or false value.

The following code snippet shows the Bool type in use:

var skyIsBlue = true
var seaIsGreen = false
var areYouKidding:Bool = true

skyIsBlue = !true //---skyIsBlue is now false---
println(skyIsBlue) //---false---

Bool variables are often used in conditional statements such as the If statement:

if areYouKidding {
     println("Just joking, huh?")
} else {
     println("Are you serious?")
}

Implicitly Unwrapped Optionals

In the previous section you saw the use of the optional type and the use of the ! character to unwrap the value of an optional variable. The problem with this is that you likely will end up with a lot of ! characters in your code whenever you access the value of the optional variable. To access the value of an optional variable without using the ! character, you can declare an optional type as an implicitly unwrapped optional.

Consider the following declaration:

//---implicit optional variable---
var str2: String! = "This is a string"

Here, str2 is an implicitly unwrapped optional. When you access str2, there is no need to use the ! character, as it is implicitly unwrapped:

println(str2) // "This is a string"

If str2 is set to nil, accessing the str2 will return a nil:

str2 = nil
println(str2) // nil

Optional Binding

Many times you need to assign the value of an optional type to another variable or constant. Consider the following example:

var productCode:String? = getProductCode("Diet Coke")
if let tempProductCode = productCode {
     println(tempProductCode)
} else {
     println("Product Code not found")
}

In this snippet, getProductCode() is a function that takes in a product name (of String type) and returns a product code (a String value) or nil if the product cannot be found. As such, the productCode is an optional String.

To assign the value of productCode to another variable/constant, you can use the following pattern:

if let tempProductCode = productCode {

Here, you are essentially doing this: check the value of productCode; if it is not nil, assign the value to tempProductCode and execute the If block of statements—otherwise, execute the Else block of statements.

You can easily test this by setting productCode to a value:

productCode = "12345"
if let tempProductCode = productCode {
    println(tempProductCode)
} else {
    println("Product Code not found")
}

The preceding code snippet will print out:

12345

If you now set productCode to nil:

productCode = nil
if let tempProductCode = productCode {
    println(tempProductCode)
} else {
    println("Product Code not found")
}

The preceding code snippet will print out:

Product Code not found

Unwrapping Optionals Using “?”

So far you have learned that you can use the ! character to unwrap an optional type’s value. Consider the following scenario:

var str:String?
var empty = str!.isEmpty

From this code snippet, str is an optional String and isEmpty is a property from the String class. In this example, you want to know if str is empty, so you call the isEmpty property. However, the preceding code will crash, as str contains nil, and trying to call the isEmpty property from nil results in a runtime error. The use of the ! character is like telling the compiler: I am very confident that str is not nil, so please go ahead and call the isEmpty property. Unfortunately, str is indeed nil in this case.

To prevent the statement from crashing, you should instead use the ? character, as follows:

var empty = str?.isEmpty

The ? character tells the compiler: I am not sure if str is nil. If it is not nil, please call the isEmpty property; otherwise, ignore it.

Using Enumeration in Switch Statements

Enumerations are often used in Switch statements. The following code snippet checks the value of colorOfBag and outputs the respective statement:

switch colorOfBag {
    case BagColor.Black:
           println("Black")
    case BagColor.White:
           println("White")
     case BagColor.Red:
           println("Red")
     case BagColor.Green:
           println("Green")
     case BagColor.Yellow:
          println("Yellow")
}

Because the type of colorOfBag (which is BagColor) is already known, Swift allows you to specify only the enumeration members and omit the name:

switch colorOfBag {
  case .Black:
      println("Black")
  case .White:
      println("White")
  case .Red:
      println("Red")
  case .Green:
      println("Green")
  case .Yellow:
      println("Yellow")
}

Enumeration Raw Values

One of the common operations that you need to perform with enumerations is that of associating a value with the members of an enumeration. For example, suppose you want to store the value of colorOfBag to a file as a string (or, if you like, an integer). In this case, Swift makes it very easy for you to associate a value to members of an enumeration:

enum BagColor: String {
  case Black = "Black"
  case White  = "White"
  case Red = "Red"
  case Green = "Green"
  case Yellow = "Yellow"
}

After the declaration of the enumeration, append the enumeration name with a colon (:) and indicate the type of data to which you want each member associated (all members must be of the same type):

enum BagColor: String {

Within the enumeration, you then assign each member to the desired value, of the type that you have just specified:

case Black = "Black"
case White = "White"
case Red = "Red"
case Green = "Green"
case Yellow = "Yellow"

To obtain the value of an enumeration, use the rawValue property of the enumeration instance:

var colorOfBag:BagColor
colorOfBag = BagColor.Yellow
var c = colorOfBag.rawValue
println(c) //---prints out "Yellow"---

The rawValue property will return the value that you have assigned to each member of the enumeration.

What about the reverse? If you have a string of "Green", how do you convert it to the enumeration member? You can do so via the rawValue initializer, as follows:

var colorOfSecondBag:BagColor? = BagColor(rawValue:"Green")

The preceding statement uses the rawValue initializer to try to convert the string "Green" to the enumeration member from BagColor. Because the rawValue initializer does not guarantee that it is able to return an enumeration member (imagine you pass in a value of, for example, "Brown"), it returns an optional value—hence, the ? sign in the statement. Once the value is returned, you can proceed to use it:

if colorOfSecondBag == BagColor.Green {
...
}

If you want to use the rawValue property on colorOfSecondBag, you should confirm that it is not nil before proceeding to use it:

//---print only if colorOfSecondBag is not nil---
if colorOfSecondBag != nil {
println(colorOfSecondBag!.rawValue)
}

You also need to have a ! character to force unwrap the value of colorOfSecondBag before accessing the rawValue property.

Auto-Increment for Raw Values

In the previous section you saw that you could assign string values to each member in an enumeration. Very often, you would also assign integer values instead of strings. A good example is when you are representing the day of a week, as shown in the following code snippet:

enum DayOfWeek: Int {
   case Monday = 1
   case Tuesday = 2
   case Wednesday = 3
   case Thursday = 4
   case Friday = 5
   case Saturday = 6
   case Sunday = 7
}

From the preceding statements, you can see that each day of the week is assigned an integer value—Monday is assigned 1, Tuesday is assigned 2, and so on. The following statements show how it can be used:

var d = DayOfWeek.Wednesday
println(d.rawValue) //---prints out 3---

When integer values are used for raw values within an enumeration, they are automatically incremented if no values are specified for subsequent members. For example, the following code snippet shows that only the first member within the DayOfWeek enumeration is set to a value:

enum DayOfWeek: Int {
   case Monday = 1
   case Tuesday
   case Wednesday
   case Thursday
   case Friday
   case Saturday
   case Sunday
}

Due to auto-incrementing of integer raw values, the following will still work:

var d = DayOfWeek.Thursday
println(d.rawValue) //---prints out 4---

Associated Values

The previous section demonstrated how you can assign a value to each member of an enumeration. Sometimes, it would be very useful to be able to store a particular value (or values) associated with a particular member of an enumeration. Consider the following code snippets:

enum NetworkType: String {
 case LTE = "LTE"
 case ThreeG = "3G"
}
enum DeviceType {
 case Phone (NetworkType, String)
 case Tablet(String)
}

The first enumeration, NetworkType, represents the type of network to which a phone can connect. The second enumeration, DeviceType, represents two types of devices: Phone or Tablet. If a device is a phone, you would want to store some values associated with it—in this case, you want to store its network type and the model of the device. If a device is a tablet, you would just store the model of the device.

To use the preceding enumerations declared, take a look at the following code snippet:

var device1 = DeviceType.Phone(NetworkType.LTE, "iPhone 5S")
var device2 = DeviceType.Tablet("iPad Air")

For device1, its type is a phone and you store the associated information (network type and model name) with it. For device2, its type is a tablet and you store its model name with it.

You can use a Switch statement to extract the associated value of an enumeration:

switch device1 {
 case .Phone(let networkType, let model):
     println("(networkType.rawValue) - (model)")
 case .Tablet(let model):
     println("(model)")
}

The preceding code snippet will output the following line:

LTE - iPhone 5S

Enumeration Functions

You can define a function within an enumeration. Using the same example used in the previous section, we’ll now add a function named info to the DeviceType enumeration:

enum DeviceType {
 case Phone (NetworkType, String)
 case Tablet(String)
 var info: String {
     switch (self) {
         case let .Phone (networkType, model):
             return "(networkType.rawValue) - (model)"
         case let .Tablet (model):
             return "(model)"
     }
 }
}

In the preceding code snippet, the info() function returns a string. It checks the member that is currently selected (using the self keyword) and returns either a string containing the network type and model (for phone) or simply the model (for tablet). To use the function, simply call it with the enumeration instance, as shown here:

println(device1.info) //---LTE - iPhone 5S---
println(device2.info) //---iPad Air---