아래의 글은 The swift programming language과 bbiguduk님, jusung님의 번역본을 보며 공부한 내용입니다.

정의

특정 타입과 관련된 함수

• 인스턴스를 위한 특정 동작, 기능을 정의하는 인스턴스 메서드, 타입 자체를 위한 타입 메서드 이렇게 두 가지로 구분할 수 있음
• swift에서는 구조체, 클래스, 열거형 모두 메서드를 정의할 수 있음

인스턴스 메서드 (Instance Methods)

정의

특정 타입의 인스턴스에 속하는 함수

• 1) 인스턴스 property에 접근하고 수정하는 방법 제공 2) 인스턴스의 목적과 관련된 기능을 제공
• 인스턴스 메서드는 자신이 속한 타입의 인스턴스에서만 호출될 수 있음

class Counter {
    var count = 0
    func increment() {
        count += 1
    }
    func increment(by amount: Int) {
        count += amount
    }
    func reset() {
        count = 0
    }
}

let counter = Counter()
// the initial counter value is 0
counter.increment()
// the counter's value is now 1
counter.increment(by: 5)
// the counter's value is now 6
counter.reset()
// the counter's value is now 0

self 프로퍼티 (The self Property)

모든 인스턴스는 자기 자체와 정확하게 일치하는 self라는 암시적 프로퍼티를 가지고 있음

사용하는 경우?

자체 인스턴스 메서드 내에서 현재 인스턴스를 참조하기 위해 self 프로퍼티를 사용함

• 특히 인스턴스 method의 파라미터 명 = 인스턴스 프로퍼티 명 인 경우 반드시 사용해야함
• 이런 경우에는 파라미터 명이 더 우선시 되고 프로퍼티를 참조하기 위해서는 self를 사용해야함

struct Point {
    var x = 0.0, y = 0.0
    func isToTheRightOf(x: Double) -> Bool {
        return self.x > x
    }
}
let somePoint = Point(x: 4.0, y: 5.0)
if somePoint.isToTheRightOf(x: 1.0) {
    print("This point is to the right of the line where x == 1.0")
}
// Prints "This point is to the right of the line where x == 1.0"

인스턴스 메서드 내에서 값 타입 수정 (Modifying Value Types from Within Instance Methods)

• 구조체, 열거형 = 값 타입
• 클래스 = 참조타입

이때, 기본적으로 값 타입의 프로퍼티는 인스턴스 method 내에서 수정될 수 없음

하지만 프로퍼티의 수정이 필요하다면 변경을 허용할 수 있음

1. 인스턴스 메서드가 메서드 내부에서 프로퍼티 내용을 변경함
2. 암시적 self 프로퍼티에 새로운 인스턴스를 할당하고
3. 메서드가 종료되면 새로운 인스턴스가 기존의 인스턴스를 대체하게 됨

• 키워드 mutating

struct Point {
    var x = 0.0, y = 0.0
    mutating func moveBy(x deltaX: Double, y deltaY: Double) {
        x += deltaX
        y += deltaY
    }
}
var somePoint = Point(x: 1.0, y: 1.0)
somePoint.moveBy(x: 2.0, y: 3.0)
print("The point is now at (\(somePoint.x), \(somePoint.y))")
// Prints "The point is now at (3.0, 4.0)"

let fixedPoint = Point(x: 3.0, y: 3.0)
fixedPoint.moveBy(x: 2.0, y: 3.0)
// this will report an error

• 만약 위의 코드처럼 인스턴스가 상수로 선언이 됏다면 내부 프로퍼티가 변수로 선언이 됐어도 변경이 불가능함

변경 메서드 내에서 self 할당 (Assigning to self Within a Mutating Method)

• mutating method는 아래와 같이 self에 아예 새로운 인스턴스를 할당할수도 있음

struct Point {
    var x = 0.0, y = 0.0
    mutating func moveBy(x deltaX: Double, y deltaY: Double) {
        self = Point(x: x + deltaX, y: y + deltaY)
    }
}

타입 메서드 (Type Methods)

• 타입 자체의 메서드
• 키워드 static
• class의 경우에는 타입 메서드를 overriding 할 때 class 키워드 사용할 수 있음

class SomeClass {
    class func someTypeMethod() {
        // type method implementation goes here
    }
}
SomeClass.someTypeMethod()

• 타입 메서드 내에서 self를 호출한다면 이는 인스턴스가 아닌 타입 자체를 참조함!

struct LevelTracker {
    static var highestUnlockedLevel = 1
    var currentLevel = 1

    static func unlock(_ level: Int) {
        if level > highestUnlockedLevel { highestUnlockedLevel = level }
    }

    static func isUnlocked(_ level: Int) -> Bool {
        return level <= highestUnlockedLevel
    }

    @discardableResult
    mutating func advance(to level: Int) -> Bool {
        if LevelTracker.isUnlocked(level) {
            currentLevel = level
            return true
        } else {
            return false
        }
    }
}

class Player {
    var tracker = LevelTracker()
    let playerName: String
    func complete(level: Int) {
        LevelTracker.unlock(level + 1)
        tracker.advance(to: level + 1)
    }
    init(name: String) {
        playerName = name
    }
}

var player = Player(name: "Argyrios")
player.complete(level: 1)
print("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
// Prints "highest unlocked level is now 2"

player = Player(name: "Beto")
if player.tracker.advance(to: 6) {
    print("player is now on level 6")
} else {
    print("level 6 has not yet been unlocked")
}
// Prints "level 6 has not yet been unlocked"