Can you help me understand self better?

Hi Kristopher,

self is definitely one of those things that takes a while to get used to. In my case, I don't think it ever sank in from hearing the concept explained, it just took lots of practice and eventually it made sense.

That said, I'm going to have a go at explaining it in a common sense way.

Let's take a look at a simple example. I'm going to use a class even though a struct would probably be a better data structure. The concept is mostly the same between the two structures, but class is what you'll see in other languages so this might look more familiar.

class Person {
    var name: String = "kristopher"
}

Here we have a super simple class that defines a Person. We can create an instance by doing something like:

let first_person = Person()

This will create an instance of Person and give it the name 'kristopher'. We can change that value by accessing the name property:

first_person.name = "alice"

Obviously, we don't always want to create an instance of a class and then manually change its properties. Most of the time we want to instantiate the object with it having the intended properties right away.

This is where initialisers come in. An Initialiser is basically just a method but with the special feature that it is called as soon as a new object is created. This means we can specify as parameters to this method the properties we want to set up when a new instance is created.

Let's add an initialiser so we can specify the name when we create an instance:

class Person {

    var name: String

    init(name: String) {
        self.name = name
    }
}

Now that we have an initialiser we have to specify a name when we call Person(), so creating a new Person looks like this:

second_person = Person(name: "bob")

Now we've introduced self into this mix. The reason that self exists is so that you can access instance-level properties from the methods inside the instance.

It's obvious how we would do that from outside the instance. If we want to access the name property on the second_person instance, we can write:

second_person.name

But inside the instance, at least at compile time, we don't know what the identity of that instance is, so we can't write second_person.name inside a method. The job of self is to be a stand-in for whatever that instance's identity is. So we can access self.name from anywhere in the instance.

Some languages, like Python, force you to be explicit like this and always use self when accessing these properties. Swift lets you be a bit lazy, and will only make you use self when a method has its own name that conflicts with an instance-level name. We see that we have this exact situation with our init: it has its own parameter called name, so we use self to distinguish the variable in the instance from the variable in the method:

self.name = name // left is the instance, right is the method

But if we create a method that doesn't have a conflicting property, we can drop the self:

class Person {

    var name: String

    init(name: String) {
        self.name = name
    }

    func sayHello() {
        print("Hello, \(name)")
    }
}

Our sayHello method doesn't have a parameter called name so in the print statement we could write \(self.name), but because Swift knows which name we are referring to, it lets us just write \(name).

Hope that helps!

Cheers

Alex