iOS Iphone Developer Swift

Why, oh Why, did Apple take away ARC just to give us Optionals!?

I’m having trouble understanding optionals so here is a shot at explaining them. ūüôā

var thisIsAnInt: Int

Simple, this is an Int variable declaration.

var couldBeAnInt: Int?

This on the other hand is an optional variable declaration.

This optional declaration doesn’t mean: “this is an int, which is optional”.

It reads more like: This is an OPTIONAL variable. ¬†It’s a type of variable in and of itself. ¬†Its NOT NECESSARILY an Int. ¬†It just may or may NOT contain an Int”.


Ok so what is it for and when do you use it.  Well that part seems simple enough:

If that variable can or could or may be nil at some point, it’s an optional.

If the variable will always have a value, it will never be nil, its NOT an optional.

Don’t be misled by this simplicity. ¬†Some variables can start out as nil and receive a value at some point. ¬†What then?

Well it turns out there is a sort of table, if you will:

  1. Can NEVER be nil (or if it IS, its a bug) = non-optional variable….you know, the regular kind
  2. Starts out nil but NEVER ends up nil after init (or if it is, its a bug) = implicitly unwrapped optional
  3. Nil value has meaning and is expected (if it is, its NOT a bug) = optional

Yeah, thanks for confusing me :S

Here is another way around it:

var perhapsInt: Int? //this is perhaps an Int
perhapsInt = 1 //here we assign it an int
if perhapsInt != nil { //now we check to see if its nil before using it
     let intString = String(perhapsInt!) //IF it isn't, then we can access it by using !

you can also check for that in a different way:

var perhapsInt:Int?
perhapsInt = 1 
if let actualInt = perhapsInt {

Here is the kicker:

var perhapsInt: Int?
let definiteInt = perhapsInt ?? 2
println(definiteInt) // prints 2
perhapsInt = 3
let anotherInt = perhapsInt ?? 4
println (anotherInt) // prints 3

And it¬†gets trickier what with ?? and variable != nil. ¬†So let’s throw everything out the window and start anew. ¬†Let’s define a function we might actually be interested in:

Assume we have an array of locations:

let errorCodes = ["100","200","300","400", "500"]
func findErrorCode (code : String, errorCodes: [String])-> String {
for tempCode in errorCodes {
     if ( tempCode == code) {
     return code
return ""

This is a function we wrote to find a particular code¬†inside an array of possible error codes. ¬†We call it by passing it in a code¬†and the array of possible codes. ¬†If we pass it a code¬†that is NOT in the array, let’s say “700”, then the “internal if” will not evaluate to true and we must return nil. ¬†We must return nil because otherwise, because the function is meant to return a String (the name of the matched code) && that “if block” didn’t hold true, you get a compiler error because we are not being exhaustive. ¬†This means, if we pass the function a value that IS in the array, great, we will get a ‘return code’. ¬†However, if we pass it a value that is NOT in the array, the function would not be returning anything. ¬†So we NEED to return something for it to work.

We could return an emply value but consider the following. ¬†Let’s say we wish to display that code¬†returned in the console, via println (or plot it on a map of servers for example). ¬†The point being that we need to do something with the returned code:

if findCode("700", errorCodes) {

So how do we account for such a possibility? ¬†We need to define the return value of the function findCode as an optional. ¬†To do this we add this to the variable “?”. ¬†Here is what the function would look like:

func findCode (code : String, errorCodes: [String])-> String? {
for tempCode in errorCodes {
     if ( tempCode == code) {
          return code
return nil

Now we can actually return a String value, maybe, or we could be returning an Optional value.

Great, now let’s asume the plot function looks like this:

func plotOnMap (code: Int) -> () {
     println("This line of code magically plots the code on a server map :)")

Ok so now we can say

let receiver = findCode("200",errorCodes)
if receiver {

The issue is that the value returned by findCode, is Optional.  So the value of receiver will be optional.

This is what is called “implicitly defined optional“. ¬†We have implicitly defined receiver to be an optional because the return of the function is an optional itself.

We also have another issue, plotOnMap() takes an Int, not a String.  So we have actually defined receiver as:

let receiver: String? = findCode("400",errorCodes) // inferred type String?

Notice we have defined it as String?, not String.  This means receiver can hold a String or a nil, because its being defined as an Optional type, not a String type.

So what can we do?  We can ask it for a value only if it HAS one:

let receiver = findCode("400",errorCodes) 
if receiver {
	plotOnMap(receiver!) // We use of the ! operator to unwrap the value to String

This would indeed fix the problem. ¬†You have solved the possibility of an optional in a function you wrote yourself. ¬†But there is always the other case, values returned by functions you DIDNT write! ¬†Ugh! ¬†Remember I mentioned that our plotOnMap() takes an Int, and not a String? ¬†And we are in fact unwrapping an implicitly defined variable (called receiver) into a String (cause that’s what the function returns? ¬†Well we need to convert it into an int, which is simple in Swift, just say string.toInt(). ¬†This means we have to do this:

if let receiver = findCode("400",errorCodes) {

But if you jump to definition on toInt(), you will notice that it also returns an optional.  So we would need to do something more convoluted:

if let receiver = findCode("400",errorCodes) {
	if let receiverErrorCode = receiver.toInt() {

which is quite confusing. ¬†So there is a Swift syntax which let’s you condense this into:

if let receiverErrorCode = findCode("400",errorCodes)?.toInt() {

It would be prudent just to add an else to the if to be safe ūüôā

Iphone Developer Swift

Swift Tutorial II

Ok so in the first tutorial we covered let, which is the keyword for defining constants.

let thisBeAConstant = 3.141

Now we are going to cover variables, which use the var keyword like so:

var thisVariable = time

Notice 2 things about Swift:

1) We don’t use ; at the end of a line. ¬†That’s just weird ūüôā

2) We don’t have to specify the type. ¬†The type is inferred by whatever value you pass in, so:

var someString = “this is a string”

var someInteger = 5

So Swift is kinda smart. ¬†Now let’s meet some old friends “Hao jiu bu juan”


var¬†energies = [“solar”,¬†“wind”,¬†“fossil”, “this is a mixed array”,¬†39]

var¬†energies:String[]¬†= [“solar”,¬†“wind”,¬†“this is a string array”]

And of course we can perform some basic operations such as:


var¬†item1 =¬†energies[0] ¬† //¬†“solar”


energies.insert(“hydro”, atIndex: 2)


energies[3] = “geothermal”






energies¬†+= [“biomass”,¬†“hamster”]


var lengthofArray = energies.count


var arrayIsEmpty = energies.isEmpty


energies.removeAll(keepCapacity: true)
If we used let energies, then our array is immutable, vs if we used var energies which means its mutable.
Easy as pie.

var energies = [

¬† ¬†¬†“Solar”:¬†“Thermal”,
¬† ¬†¬†“Photovoltaic”¬†:¬†“Grid”,
¬† ¬†¬†“Nuclear”¬†:¬†“Dangerous”
Here our keys are Solar, Photovoltaic & Nuclear.  These keys can be strings or numeric values such as integers.
Once again we can:
let¬†cheapestSolarEnergy =¬†energies[“Solar”]
var energiesCount = energies.count
energies[“Solar”] =¬†“PV”
energies[“Nuclear”] =¬†nil;
energies[“Geo”] =¬†“Thermal”
and of course the value of a key can be an array or another dictionary:

var typesOfEnergy =

¬† ¬† platforms[“Solar”]: [“Thermal”,¬†“PV”,¬†“GridTied”],
¬† ¬† platforms[“Wind”]: [“Autonomous”,¬†“GridTied”],
¬† ¬† platforms[“Nuclear”] : [“Fusion”,¬†“Fission”,“Meltdown”]
and we would read it:
var type1 = typesOfEnergy[“Solar”][0]
See you next time! ūüôā