Chapter 1 – Tutorials

Informations presented on this page may be incomplete or outdated. You can find the most up-to-date version reading my book Learn Swift by examples. Beginner level

What we will do:
In this part we will learn how to create a class with properties and methods. We add a class to represent game board and another one to be an entry point to the whole game logic.

We will learn new things:

array,
class,
constant and variable,
enumeration,
functions,
range operators.

In this part we cover the following topics

Creating project
Class
Properties
Enumerations
Arrays
Functions and methods
Add EngineGameBattleship class
Last step

Source code for this chapter.

Creating project

To play with Swift we have to use right tool. In this case I recommend Xcode which can be found by icon

Just after start a welcome screen should be displayed

Select Create a new Xcode project
If this window is not present on a screen press Shift + Command + N or select from top menu File / New / Project...

New project template selection window is then shown. Select Command line tool

Next some project identification data should be provided.

Product Name -- name of our "product". Choose it carefuly, because changing it in a future, although possible, is not so easy.
Team -- select team if any.
Organzation Name -- just a name of an "organization"; may be a company name, developer name as in my case or any other name.
Organization Identifier -- identifier of an "organization"
Bundle Identifier -- this is something which uniquely identify our "product" in a scale of a whole glob, and is formed as a result of concatenating Organzation Identifier and Product Name. This is why Organzation Identifier should be something realy unique -- reverse domain name is on of a method to meet this condition. As long as we only test some code or we don't want to put it in the App Store both names may be any strings we want.
Language -- select Swift.

After pressing the Next button folder to save project should be given

If we want to keep the code under source control, check Create Git repository on my Mac.
This was the last step and main Xcode window should appaear

Selecting main.swift file from the tree displayed in the Project navigator located on the left part of the main window displays the code located in this file

Press Command + R, select from top menu Product / Run or press "play" button to compile and execte a code

Sometimes firs run takes more time than you expect. Please be patient and be sure that console window is displeyed. If not, it can be turn on with a button located in the right-bottom corner of a main window.

That's all. Now the project is ready to be developed.

Class

Let's start with creating a Board class to be used to represent game board in our game. Press Command + N or select from top menu File / New / File...

Alternatively we can select EngineGameBattleship group in the Project navigator, right click on it and select from pop-up menu New File...

Then select macOS and Swift File and accept it pressing Next button

Provide file name, which in case of Swift doesn't have to be consistent with the class name we want to put inside (although it's a good habit)

Press Create to create the file

Initial contents of this file is almost empty except import declaration

import Foundation

1	import Foundation

It lets us access symbols that are declared in another module/library/framework (different names are used). The Foundation is one of the fundametal framework. It provides a base layer of functionality for apps and other frameworks, including data storage and persistence, text processing, date and time calculations, sorting and filtering, and networking.

Add

class Board {
}

1 2	class Board { }

code to this file -- this would be a "frame" enclosing code of a class.

At the very first beginning add some variables to store information about board: number of rows end columns

class Board {
	private let rows, cols: Int
    private var board: [[CellType]]
}

class Board {

private let rows, cols: Int

private var board: [[CellType]]

}

This two simple additons requires a lot of comments.

Properties

Declaring "variables" in Swift we have two options.

With kyword var we can declare real variable -- a components of our class whose contents we can change through a time. It may be initiated as integer storing value 7 and later it can be changed to 3.
With kyword let we can declare constant (variable) -- a components of our class whose contents, when initiated, may not be change through a time. If initiated as integer storing value 7 it can not be changed and keeps this value forever.

Remarks:

Both types of objects sometimes are called field or property of a class.
Despite we differ variables and constants, if this not lead to confusion, we will refere both them as variables.

Every object in Swift must have a type and this type must be known during compilation. Type defines kind of object allowed to be stored inside an object.

We can explicitely define it as we did it above. From the above code we know that both rows and cols are of integer type (Int) while board is a two-dimensional array (because of double square brackets pairs [[]]) of objects of type CellType.
Type can be inferred based on the object substitution instruction. From the code below,

Swift

var foo = 1

1

var foo = 1

we infer that foo variable must be an integer. So, to avoid Type annotation missing in pattern error we have to provide either a type annotation when we declare constant or variable or we have to assign a value to allow compiler infer the type of constant or variable.

Every object must have a value or must be explicitely defined as optional which is a way to indicate that this object may not have a value. At this moment we will see Class 'Board' has no initializers message. Even if we add an initializer but don't initialize all properties we will see another message: Return from initializer without initializing all stored properties. Optionals are used in situations where a value may be absent. For example an optional integer is written as Int?.

var thisMayBeEmpty: Int?

1	var thisMayBeEmpty: Int?

We set an optional variable to a valueless state by assigning it the special value nil. Notice that Swift's nil is not the same as nil in Objective-C or other programming languages. In Objective-C nil is a pointer to a nonexistent object. In Swift, nil is not a pointer. It is the absence of a value of a certain type. We may say, that nil is a value which tell us, that there is no correct value. In some sense it plays the same role as NaN "number" for numeric values. Optionals of any type we want can be set to nil, not just object types. Conversely, nil cannot be used with nonoptionals. If a variable (rather constant) in our code needs to take no value, we have to declare it as an optional value of the appropriate type. More details about optionals will be given in next chapter.

Once we've declared constant or variable of a certain type, we can't redeclare it, or change it to store values of different type. Nor can we change a constant into a variable or a variable into constant.

private is an access modiffier and prevents other classes from using internal details of our class. There are many reasons we do this and this is one of fundamental assumption of object oriented programming. Discussing this topic is out of scope of this book, so please refer to some external sources.

Enumerations

Our board variable is a two dimensional array of type CellType but this type has not been defined so far. To fix this we can use enumeration. An enumeration is a way we define a one common type for a group of related values. It enables us to work with those values in a type-safe way within our code. Instead of using unrelated (from compilator point of view) values we create a "set" of values and specify that in some places of our code only values from this "set" will be used.

enum CellType {
    case none, empty, hit, notAllowed, rescue, ship, shot
}

enum CellType {

case none, empty, hit, notAllowed, rescue, ship, shot

}

In our case we have "set" CellType with values "hidden" under the names none, empty, hit, etc. Saying the truth we pay greater attention to names than values. Vaues are what we really need and what in most cases we will use in our code when we work with enumerations.

The meaning of each case is as follows:

none -- nothing, none cell should have this value; use to signal unexpected problems,
empty -- empty cell; cell where we can put a ship or we can shot,
hit -- cell where we have already shot and hit,
notAllowed -- cell we can't put a ship or shot,
rescue -- cell around sunken ship,
ship -- ship,
shot -- cell where we have already shot but miss.

Arrays

An array stores values of the same type in an indexed order. The same value can appear in an array multiple times at different positions.

import Foundation

// Declare an array
var mutableArrayDeclaration: [String]
let immutableArrayDeclaration: [String]

// Define an empty array
var mutableArray1 = [String]()
var mutableArray2 = Array<String>()
let immutableArray = [String]()

// We can do
mutableArray1.append("Zero")
mutableArray1.append("One")
mutableArray1.append("Two")
// or
mutableArray2 = ["zero", "one", "two"]
// but can't do
//mutableArrayDeclaration.append("Zero")
// or
//immutableArray.append("Zero")

print(mutableArray1)
print(mutableArray2)

import Foundation

// Declare an array

var mutableArrayDeclaration: [String]

let immutableArrayDeclaration: [String]

// Define an empty array

var mutableArray1 = [String]()

var mutableArray2 = Array<String>()

let immutableArray = [String]()

// We can do

mutableArray1.append("Zero")

mutableArray1.append("One")

mutableArray1.append("Two")

// or

mutableArray2 = ["zero", "one", "two"]

// but can't do

//mutableArrayDeclaration.append("Zero")

// or

//immutableArray.append("Zero")

print(mutableArray1)

print(mutableArray2)



["Zero", "One", "Two"]

["zero", "one", "two"]

In Swift, differently than in Objective-C, we can't create an array that has pre-allocated memory but does not contain elements. We can't create an empty array of fixed, predefined size. A good news is that we can easily concatenate arrays.

// We can't
//var mutableArray3 = [String](repeating: nil, count: 10)
// but we can
var mutableArray3 = [String](repeating: "", count: 5)
print(mutableArray3)

mutableArray3[3] = "THREE"

print(mutableArray3)

mutableArrayDeclaration = mutableArray2 + mutableArray3

print(mutableArrayDeclaration)

mutableArrayDeclaration += ["FIVE", "SIX"]

print(mutableArrayDeclaration)

// We can't

//var mutableArray3 = [String](repeating: nil, count: 10)

// but we can

var mutableArray3 = [String](repeating: "", count: 5)

print(mutableArray3)

mutableArray3[3] = "THREE"

print(mutableArray3)

mutableArrayDeclaration = mutableArray2 + mutableArray3