Swift Methods

1. Methods 👩‍💻

Methods는 Functions 중에서 특정 Type 과 연관된 Functions 를 말한다.

Classes, Structures, Enumerations 모두 Instance 의 작동을 위한 Instance Methods를 정의하고, Encapsulate(캡슐화) 할 수 있다. 또한 Type을 위한 Type Methods 역시 정의할 수 있는데, 이것은 Objective-C 의 Class Methods 와 유사하다.

Objective-C 에서 Classes 는 Methods 를 정의할 수 있는 유일한 타입인 반면, Swift 는 Classes 뿐만 아니라 Structures 와 Enumerations 에서도 정의할 수 있도록 유연성을 높였다.

---

2. Instance Methods 👩‍💻

Instance Methods 는 Classes, Structures, Enumerations 의 Instance 에 속해 있는 함수로, Instance 의 Properties 에 접근, 수정하거나 Instance 의 작동을 위한 기능을 제공한다.

Instance Methods 는 그것이 정의된 context 내의 다른 모든 Instance Methods 와 Instance Properties 에 대해 암시적인 접근 권한을 갖는다. 그리고 Instance Methods 는 Instance Properties 와 마찬가지로 Instance 없이 독립적으로 호출이 불가능하다.

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

let counter = Counter()

Counter Class 를 정의하고, Counter 타입의 counter instance 를 선언했다.
Instance Methods 는 Instance Properties 와 마찬가지로 dot Syntax를 이용해 호출한다.

print(counter.count)    // 0

counter.increment()
print(counter.count)    // 1

counter.increment(by: 5)
print(counter.count)    // 6

counter.reset()
print(counter.count)    // 0

1. The self Property

Instance 는 self라고 불리는 Instance 자기 자신과 동일한 Property를 암시적으로 갖는다(implicit self property).

원래 Methods 가 자기 자신의 context 외부, 즉 위 경우 Counter Class 의 context 에 정의된 Instance Properties 나 다른 Instance Methods 에 접근하기 위해서는 다음과 같이 코드를 작성해야한다.

func increment() {
    self.count += 1
}

하지만 Swift 는 context 내에서 대상을 찾지 못 할 경우, 현재 Instance 의 context 에서 찾도록 암시적으로 self를 처리하므로, 명시적으로 self 키워드를 붙일 필요가 없다.

func increment() {
    count += 1
}

그러나 Methods 의 parameters 와 properties 가 이름이 중복될 경우 parameters 가 우선권을 갖기 때문에 암시적 self를 사용할 수 없다. 그러므로 이 경우 명시적으로 self를 처리해야한다.

struct Point {
    var x = 0.0, y = 0.0
    func isToTheRightOf(x: Double) -> Bool {
        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")
}

This point is to the right of the line where x == 1.0

2. Modifying Value Types from Within Instance Methods

Structures 와 Enumerations 는 Value Types다. 기본적으로 Value Type 의 Properties 는 Instance Methods 에 의해 수정될 수 없다(immutable).

수정이 필요할 경우 mutating 키워드를 사용해 수정을 허용하도록 명시해야한다.
mutating Methods 는 메서드가 종료될 때 Properties 를 변경한다. 또한 이 메서드는 implicit self property에 완전히 new Instance를 할당할 수도 있으며, 'new Instance'는 메서드가 종료될 때 'original Instance'를 대체한다.

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)
print("The point is at (\(somePoint.x), \(somePoint.y))")

somePoint.moveBy(x: 2.0, y: 3.0)
print("The point is now at (\(somePoint.x), \(somePoint.y))")

The point is at (1.0, 1.0)
The point is now at (3.0, 4.0)

mutating 키워드를 이용해 Structures 의 Properties 를 수정하는 것은 Structure Instance 를 var로 선언한 경우에만 가능하다.
Stored Properties of Constant Structure Instances

3. Assigning to self Within a Mutating Method

위 2번에서 mutating Methods 가 Properties 를 변경하는 예를 보았다. 이번에는 implicit self property에 완전히 new Instance를 할당해 original Instance를 대체 하는 로직을 살펴본다.

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

anotherMoveBy(x:y:)는 self, 즉, Instance 자기 자신 을 Point(x:y)를 이용해 새 Instance 를 생성한 후, 기존의 Instance 를 대체한다.

var somePoint = Point(x: 1.0, y: 1.0)
print("The point is at (\(somePoint.x), \(somePoint.y))")

somePoint.moveBy(x: 2.0, y: 3.0)
print("The point is now at (\(somePoint.x), \(somePoint.y))")

somePoint.anotherMoveBy(x: 5.0, y: 2.0)
print("The point is now at (\(somePoint.x), \(somePoint.y))")

The point is at (1.0, 1.0)
The point is now at (3.0, 4.0)
The point is now at (8.0, 6.0)

그리고 과연 이때 new Instance 를 이용해 original Instance 를 대체하면 somePoint의 메모리 주소가 바뀌는지도 함께 확인해 보았으나 변경되지 않는 것으로 보인다.

func address(of object: UnsafeRawPointer) -> NSString {
    let address = Int(bitPattern: object)
    return NSString(format: "%p", address)
}

var somePoint = Point(x: 1.0, y: 1.0)
print("Point's memory address is \(address(of: &somePoint))")

somePoint.moveBy(x: 2.0, y: 3.0)
print("Point's memory address is \(address(of: &somePoint))")

somePoint.anotherMoveBy(x: 5.0, y: 2.0)
print("Point's memory address is \(address(of: &somePoint))")

Point's memory address is 0x10377c840
Point's memory address is 0x10377c840
Point's memory address is 0x10377c840

---

3. Type Methods 👩‍💻

1. Type Method Syntax

Type Property Syntax 와 마찬가지로 Methods 앞에 static 키워드를 사용한다.

struct SomeStructure {
    static func someTypeMethod() {
        // type method implementation goes here
    }
}

Type Methods 에서 self는 Instance 가 아닌 Type itself, 즉 Type 자체를 가리킨다.

그리고 Instance Methods 와 마찬가지로, self를 암시적으로 처리하므로 Type 의 context 에 정의된 Type Properties 나 Type Methods 에 접근하기 위한 self를 생략할 수 있다.

차이점이 있다면 다음과 같다.

• Instance Methods는 context 내부에 정의된 Instance Properties와 Instance Methods에 접근 가능하다.
  또한 Type Methods 접근도 가능한데, Type 의 full name을 붙여 접근 가능하다.
• Type Methods는 context 내부에 정의된 Type Properties와 Type Methods에 접근 가능하다.

2. Type Method Examples

게임을 하나 만들자. 이 게임에는 게임 레벨이 존재하며, 게임의 레벨은 1에서 시작한다. 그리고 플레이어 중 누군가 게임의 레벨을 해제하면 게임의 최고 레벨이 올라가고, 모든 플레이어가 해당 레벨의 게임을 할 수 있다.

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
    }
    
    mutating func advance(to level: Int) -> Bool {
        if LevelTracker.isUnlocked(level) {
            currentLevel = level
            return true
        } else {
            return false
        }
    }
}

• highestUnlockedLevel : 플레이 가능한 게임의 최고 레벨.
• currentLevel: 현재 게임 레벨.
• unlock(_:) : 다음 레벨 게임을 해제한다. 즉, 플레이 가능한 게임의 최고 레벨이 올라간다.
• isUnlocked(to:) : 게임 레벨이 해제되었는지 확인한다.
• advance(to:) : 게임 레벨을 올린다.

이제 이 게임 규칙을 적용해 플레이를 진행할 게임 플레이어를 만든다.

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
    }
}

• tracker : 게임을 규칙을 저장한 LevelTracker 를 변수로 갖는다.
• complete(level:) : 현재 레벨의 게임을 완료하면 LevelTracker 의 unlock(_:) 메서드를 이용해 게임의 최고 레벨을 해제하고, 현재 게임 레벨을 올린다.

여기서 주목해야 할 점은 LevelTracker 는 Structure 고, Player 는 Class 라는 점이다. 또한 게임 설정의 LevelTracker 를 보면 highestUnlockedLevel 는 Type Property 고, currentLevel 은 Instance Property 다.

즉, 어떤 플레이어가 게임의 최고 레벨을 높여 놓으면 그 다음 플레이어는 해당 레벨을 잠금이 해제된 게임을 이용할 수 있음을 의미하며, 최고 레벨 해제와 무관하게 새 플레이어는 항상 레벨 1로 게임을 시작해야함을 의미한다.

게임을 진행해보자.

var room1 = Player(name: "Harry")
print("\(room1.tracker), Harry is playing level \(room1.tracker.currentLevel).")

LevelTracker(currentLevel: 1), Harry is playing level 1.

해리가 플레이어를 만들고 1번 방에서 게임을 시작했다. 해리가 진행중인 게임 레벨은 1이다.

room1.complete(level: 1)
print("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
print("\(room1.tracker), Harry is playing level \(room1.tracker.currentLevel).")

highest unlocked level is now 2
LevelTracker(currentLevel: 2), Harry is playing level 2.

해리가 게임을 완료해 다음 레벨을 해제했다.
이제 게임의 최고 레벨은 2고, 해리는 1번 방에서 레벨 2를 진행중이다.

var room2 = Player(name: "Ron")
print("\(room2.tracker), Ron is playing level \(room2.tracker.currentLevel).")

LevelTracker(currentLevel: 1), Ron is playing level 1.

론이 새로운 플레이어를 만들었다. 론은 게임방도 새로 만들어 2번방에서 게임을 하기로 했다.
게임 설정 LevelTracker 에 의해 론 역시 레벨 1로 게임을 시작한다.

if LevelTracker.isUnlocked(2) {
    room2.tracker.advance(to: 2)
}
print("\(room2.tracker), Ron is playing level \(room2.tracker.currentLevel).")

LevelTracker(currentLevel: 2), Ron is playing level 2.

그런데 론은 레벨 1은 지루하다며 레벨 2가 해제되었는지 확인 후, 레벨을 올리기로 했고 성공했다.
그 결과 론은 2번 방에서 레벨 2를 진행중이다.

room1 = Player(name: "Hermione")
print("\(room1.tracker), Hermione is playing level \(room1.tracker.currentLevel).")

LevelTracker(currentLevel: 1), Hermione is playing level 1.

이번에는 헤르미온느가 게임을 시작하는데, 헤르미온느는 해리가 하던 1번방에서 게임을 이어서 하기로 하고 플레이어를 새로 만들어 게임에 들어갔다. 1번 방에서 해리는 레벨 2를 진행하고 있었지만 헤르미온느는 새 게임을 시작하는 플레이어이므로 게임 설정 LevelTracker 에 의해 마찬가지로 레벨 1에서 시작한다.

print("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
if room1.tracker.advance(to: 6) {
    print("Hermione is now on level 6")
} else {
    print("level 6 hasn't yet been unlocked")
}

highest unlocked level is now 2
level 6 hasn't yet been unlocked

그런데 헤르미온느는 낮은 레벨의 게임은 재미 없다며 한 번에 레벨 6으로 올리기를 원했다. 현재 게임 플레이가 가능한 최고 레벨이 2라는 것을 확인 했으나 혹시나 하는 마음에 레벨 6으로 올리기를 시도했고, 레벨 6은 아직 잠겨있다는 메시지를 받았다.

---

Reference

1. “Methods.” The Swift Programming Language Swift 5.7. accessed Nov. 27, 2022, Swift Docs Chapter 10 - Methods.