We can declare variables as follows:

var a: Int = 1

In the preceding line of code, a is declared to be of type Int, with a value of 1. Since only an Int can be assigned the value 1, Swift can automatically infer the type of a, and it is not necessary to explicitly include the type information in the variable declaration:

var a = 1

In the preceding code, it is equally clear to both Swift and the reader what type a belongs to.

The value of a var can be changed by simply assigning to it a new value:

var a = 1 
a = 2 

However, in Swift, we can also declare a constant, which is immutable, using the let keyword:

let b = 2 

The value of b is now set permanently. The following attempt to...

Swift has adopted C-style comments of both forms:

// We have used this one already 
// in previous sections of this chapter 

When it starts to get messy, with // at the beginning of each commented line, we have the following multiline comments:

/* 
This is a multiline 
comment, for those times when 
you just can't say it 
in a few words 
*/ 

Unlike some languages, you can nest these comments, which is handy if you need to comment out a large section of code that itself contains comments:

/* 
Comments can be nested, 
/* 
like this one 
*/ 
which can be helpful. 
*/ 

Swift offers a comprehensive set of collection types, as one would expect. In common with many other languages, each of these collection types will only hold values of the same type. Thus, the type of an Array of Int values is distinct from the type of an Array of Float values, for example. If you're coming from Objective C, you may quickly come to appreciate the type safety and simplicity of Swift Array objects over NSArray.

There are no separate mutable and immutable collection types, as such, since all objects in Swift can be declared with either var or let.

let myArr = [21, 22, 23] 

let count = myArr.count // 3 
let secondElmt = myArr[1] // 22 
let firstElmt = myArr.first // 21 
let lastElmt = myArr.last // 23 

myArr[1] = 100 

The basic data types of Swift, such as Int, Double, and Bool, are said to be value types. This means that, when passing a value to a function (including assignment of variables and constants), it is copied into its new location:

var x1 = 1 
var y1 = x1 
y1 = 2 
x1 == 1 // true 

However, this concept extends to String, Array, Dictionary, and many other objects that, in some languages, notably Objective C, are passed by reference. Passing by reference means that we pass a pointer to the actual object itself, as an argument, rather than just copy its value:

var referenceObject1 = someValue 
var referenceObject2 = referenceObject1 
referenceObject2 = someNewValue 

These two variables now point to the same instance.

While this pattern is frequently desirable, it does leave a lot of variables sharing the same data--if you change one, you change the others. And that's a great source of bugs.

So, in Swift, we have many more value types than reference types. This even extends...

We will take a quick tour of the most common operators in Swift, leaving such esoteric topics as custom operators for Chapter 5, Advanced Swift.

-  
+  
*  
/ 
% 

let x = (a * a) + (b * b) 

x = x + 1 

x += 1 

 -= *= /= %= 

Ways of defining and handling structured data are an important part of any programming language that supports object-oriented programming. Swift has extended the patterns typical of Objective C, Java, and the like, to include structures that are passed by value, called structs, and those that are passed by reference, called classes (see Value and reference types in this chapter). There is also the much lighter-weight tuple, which offers a kind of bridge between data structures and collection types such as dictionaries.

As well as the fact that structs are value types and classes are reference types, there are a few other points of departure, but the two structures have a lot more similarities than they do differences.

Swift offers another valuable structure, the Enum. While enumerations are a common feature of programming languages, Swift's Enum offers very much more than a simple mapping of integer values to labels.

Firstly, in cases where there is no logical mapping of Enum values to integers (or values of any other type), we can declare an Enum to be a type in its own right:

enum Color 
{ 
    case red 
    case amber 
    case green 
} 

So, here we have a case in which it would be nonsensical to map colors to integers. Swift will not allow us to try to derive some integer value from Color.red, either.

Note that the Enum name is capitalized, whereas a case is written in lowercase.

There are, however, frequent uses for an Enum that do correspond to some underlying value, and Swift lets us do this, too:

enum Medal: Int 
{ 
    case gold ...