Initialization

초기화는 클래스, 구조체, 열거형 인스턴스를 사용하기 위해 준비 작업을 하는 단계 이다. 이 단계에서 각 저장 프로퍼티의 초기 값을 설정한다. 초기화 과정은 initializer를 정의 하는 것으로 구현할 수 있다. Swift의 initializer는 값을 반환하지 않는다. 초기화와 반대로 여러 값과 자원의 해지를 위해 deinitializer도 사용할 수 있다.

저장 프로퍼티를 위한 초기값 설정 (Setting Initial Values for Stored Properties)

인스턴스의 저장 프로퍼티는 사용하기 전에 반드시 특정 값으로 초기화 돼야 한다. 이 값으로 기본 값을 설정할 수 있고, 특정 값을 설정할 수도 있다

이니셜라이저 (Initializers)

이니셜라이저는 특정 타입의 인스턴스를 생성한다. 이니셜라이저의 가장 간단한 형태는 파라미터가 없고 init 키워드를 사용하는 것이다.

init() {
    // perform some initialization here
}

struct Fahrenheit {
    var temperature: Double
    init() {
        temperature = 32.0
    }
}
var f = Fahrenheit()
print("The default temperature is \(f.temperature)° Fahrenheit")
// Prints "The default temperature is 32.0° Fahrenheit"

기본 프로퍼티

프로퍼티의 선언과 동시에 값을 할당하면 그 값을 초기 값으로 사용할 수 있다.

NOTE❗️
항상 같은 초기 값을 갖는 다면 기본 프로퍼티를 사용하는 것이 좋다. 프로퍼티에 타입을 선언하지 않아도 컴파일러는 초기 값을 참조해서 타입을 추론할 수 있다. 이 기본값은 상속시 함께 상속 된다.

struct Fahrenheit {
    var temperature = 32.0
}

커스터마이징 초기화 (Customizing Initialization

초기화 프로세스를 입력 값과 옵셔널 프로퍼티 타입 혹은 상수 값을 할당해서 커스터마이징 할 수 있다.

초기화 파라미터 (Initialization Parameters)

초기화 정의에 파라미터를 정의해 사용할 수 있다.

struct Celsius {
    var temperatureInCelsius: Double
    init(fromFahrenheit fahrenheit: Double) {
        temperatureInCelsius = (fahrenheit - 32.0) / 1.8
    }
    init(fromKelvin kelvin: Double) {
        temperatureInCelsius = kelvin - 273.15
    }
}
let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
// boilingPointOfWater.temperatureInCelsius is 100.0
let freezingPointOfWater = Celsius(fromKelvin: 273.15)
// freezingPointOfWater.temperatureInCelsius is 0.0

파라미터 이름과 인자 레이블 (Parameter Names and Argument Labels)

메소드 파라미터와 초기화 파라미터 모두 파라미터 이름과 아규먼트 레이블을 갖지만, 이니셜라이저는 특정 메소드에서 지정하는 메소드 이름을 지정하지 않고 이니셜라이저 식별자로 파라미터를 사용한다. 모든 파라미터는 아규먼트 레이블을 갖는데 만약 사용자가 이 레이블을 지정하지 않으면 Swift가 자동으로 하나를 할당해 제공한다.

struct Color {
    let red, green, blue: Double
    init(red: Double, green: Double, blue: Double) {
        self.red   = red
        self.green = green
        self.blue  = blue
    }
    init(white: Double) {
        red   = white
        green = white
        blue  = white
    }
}

인자 레이블이 없는 이니셜라이저 파라미터 (Initializer Parameters Without Argument Labels)

코드를 작성할 때 인자 레이블을 생략하는 것이 더 명료한 경우 _ 기호를 사용해 이니셜라이저에서 인자 레이블을 생략할 수 있다.

 init(_ celsius: Double) {
        temperatureInCelsius = celsius
    }

옵셔널 프로퍼티 타입 (Optional Property Types)

프로퍼티의 최초 값이 없고 나중에 추가될 수 있는 값을 옵셔널로 선언해 사용할 수 있다. 옵셔널 프로퍼티는 자동으로 nil로 초기화 된다.

초기화 중에 상수 프로퍼티 할당 (Assigning Constant Properties During Initialization)

이니셜라이저에서는 상수 프로퍼티에 값을 할당하는 것도 가능하다.

NOTE❗️
클래스 인스턴스에서 상수 프로퍼티는 초기화 중 그 클래스 안에서만 변경이 가능하고 서브클래스에서는 변경이 불가능 합니다.

기본 이니셜라이저 (Default Initializers)

만약 모든 프로퍼티의 초기값이 설정돼 있고, 이니셜라이저도 정의하지 않았다면 Swift는 모든 프로퍼티를 기본 값으로 초기화 하는 기본 이니셜라이저를 제공해 줍니다.

class ShoppingListItem {
    var name: String?
    var quantity = 1
    var purchased = false
}
var item = ShoppingListItem()

구조체 타입을 위한 맴버쪽 이니셜라이저 (Memberwise Initializers for Structure Types)

기본 이니셜라이저와 다르게 맴버쪽 이니셜라이저는 프로퍼티가 기본 값이 없어도 커스텀 이니셜라이저를 정의하지 않았다면 멤버와이즈 이니셜라이저를 제공해 준다. 이 초기자는 선언한 모든 프로퍼티를 인자로 사용한다.

struct Size {
    var width = 0.0, height = 0.0
}
let twoByTwo = Size(width: 2.0, height: 2.0)

값 타입을 위한 이니셜라이저 위임 (Initializer Delegation for Value Types)

이니셜라이저에서 다른 이니셜라이저를 호출할 수 있습니다. 이 과정을 이니셜라이저 위임이라 한다. 값 타입(structures, enumerations)과 클래스 타입(class)간 이니셜라이저 위임 동작이 다르다. 값 타입은 상속을 지원하지 않아 이니셜라이저를 자기 자신의 다른 이니셜라이저에만 사용할 수 있다. 반면 클래스 타입은 상속이 가능하기 때문에 superclass의 이니셜라이저를 subclass에서 호출 가능하다. 상속 받은 모든 프로퍼티의 초기화는 책임은 이니셜라이저에 있다. 커스텀 이니셜라이저 선언시 기본 이니셜라이저 혹은 멤버와이즈 이니셜라이저를 사용할 수 없다.

이런 제약이 이니셜라이저의 복잡성을 낮춰주고 이니셜라이저가 의도하지 않게 사용되는 것을 방지해 준다.

클래스 상속과 초기화 (Class Inheritance and Initialization)

모든 클래스의 저장 프로퍼티와 superclass로부터 상속받은 모든 프로퍼티는 초기화 단계에서 반드시 초기값이 할당돼야 한다. Swift에서는 클래스 타입에서 모든 프로퍼티가 초기 값을 갖는 것을 보장하기 위해 2가지 방법을 지원한다.

지정 생성자와 편의 생성자 문법 (Syntax for Designated and Convenience Initializers)

클래스의 지정 초기자의 문법은 값 타입 초기자와 같다.

init(parameters) {
    statements
}

편의 생성자는 기본 생성자와 문법이 같지만 init 앞에 convenience 키워드를 붙여 준다.

convenience init(parameters) {
    statements
}

클래스 타입을 위한 이니셜라이저 위임 (Initializer Delegation for Class Types)

지정 초기자와 편리한 초기자 사이의 관계를 단순하게 하기 위해 Swift는 이니셜라이저는 위임하는 호출을 위해 다음 3가지 규칙을 따른다.

• 규칙 1 지정 초기자는 반드시 직계 superclass의 지정 생성자를 호출해야 한다.
• 규칙 2 편의 생성자는 반드시 같은 클래스의 다른 생성자를 호출해야 한다.
• 규칙 3 편의 생성자는 궁극적으로 지정생성자를 호출해야 한다.

기억하기 쉽게 요약하자면

• 지정 초기자는 반드시 위임을 superclass로 해야하고
• 편리한 초기자는 반드시 위임을 같은 레벨에서 해야한다.

그림을 보면 Subclass의 편리한 초기자는 같은 레벨에서 다른 지정 생성자를 호출하고 지정 생성자는 초기화를 상위 클래스에게 위임해 상위 클래스의 지정 생성자가 호출되는 것을 확인할 수 있다.

NOTE❗️
생성자 호출의 형태가 반드시 위 처럼 되야 하는 것은 아니다. 위에서 언급만 규칙만 지켜지면 상관 없다.

2단계 초기화 (Two-Phase Initialization)

Swift에서 클래스 초기화는 2단계로 진행된다. 첫번째 단계에서는 각 저장된 프로퍼티는 초기값으로 초기화 된다. 모든 저장된 프로퍼티의 상태가 결정되면 두번째 단계가 시작된다. 두번째 단계에서는 새로운 인스턴스의 사용이 준비됐다고 알려주기 전에 저장된 프로퍼티를 커스터마이징하는 단계이다.

Swift의 컴파일러는 2단계 초기화가 에러없이 끝나는 것을 보장하기 위해 4단계 안전 확인(safety-check)을 한다.

• 안전 확인 1단계 지정 생성자는 클래스 안에서 초기화를 superclass의 생성자에게 위임하기 전에 모든 프로퍼티를 초기화 해야한다. 위에서 언급한 것 처럼 메모리에서 객체는 모든 저장된 프로퍼티가 초기 상태를 갖어야만 완전히 초기화 된것으로 간주되기 때문에 이 규칙을 만족시키기 위해 지정 생성자는 반드시 다른 생성자로 넘기기 전에 소유하고있는 모든 프로퍼티를 초기화 해야 한다.
• 안전 확인 2단계 지정 생성자는 반드시 상속된 값을 할당하기 전에 superclass의 생성자로 위임을 넘겨야 한다. 그렇지 않으면 상속된 값이 superclass이 생성자에 의해 덮어 쓰여지게 된다.
• 안전 확인 3단계 편의 생성자는 반드시 어떤 프로퍼티를 할당하기 전에 다른 생성자로 위임을 넘겨야 한다. 만약 그렇지 않으면 편의 생성자에 의해 할당된 값을 다른 클래스의 지정 생성자에 의해 덮어 쓰여지게 된다.
• 안전 확인 4단계 이니셜라이저는 초기화의 1단계가 끝나기 전에는 self의 값을 참조하거나 어떤 인스턴스 프로퍼티, 메소드 등을 호출하거나 읽을 수 없다.

이니셜라이저의 상속과 오버라이딩 (Initializer Inheritance and Overriding)

Swift에서는 기본적으로 subclass에서 superclass의 이니셜라이저를 상속하지 않는다. 이유는 superclass의 이니셜라이저가 무분별하게 상속돼 복잡하게 돼 subclass에서 이것들이 잘못 초기화 되는 것을 막기 위함이다.

만약 클래스에서 모든 프로퍼티의 초기 값이 지정돼 있고 아무런 커스텀 초기자를 선언하지 않았다면 기본 초기자 init()을 사용할 수 있다.superclass의 초기자를 오버라이드 하기 위해서는 subclass에서 그 초기자에 override 키워드를 붙이고 재정의 한다.

class Vehicle {
    var numberOfWheels = 0
    var description: String {
        return "\(numberOfWheels) wheel(s)"
    }
}

let vehicle = Vehicle()
print("Vehicle: \(vehicle.description)")
// Vehicle: 0 wheel(s)

class Bicycle: Vehicle {
    override init() {
        super.init()
        numberOfWheels = 2
    }
}

let bicycle = Bicycle()
print("Bicycle: \(bicycle.description)")
// Bicycle: 2 wheel(s)

자동 생성자 인스턴스 (Automatic Initializer Inheritance)

class Food {
    var name: String
    init(name: String) {
        self.name = name
    }
    convenience init() {
        self.init(name: "[Unnamed]")
    }
}

편의 생성자 convenience init()에서 지정생성자 init(name: String)이 호출되는 형태이다.

Food 클래스는 모든 프로퍼티의 기본값이 있는게 아니므로 맴버와이즈 이니셜라이저를 갖지는 않는다.

class RecipeIngredient: Food {
    var quantity: Int
    init(name: String, quantity: Int) {
        self.quantity = quantity
        super.init(name: name)
    }
    override convenience init(name: String) {
        self.init(name: name, quantity: 1)
    }
}

수퍼클래스의 init(name: name) 생성자를 상속받아 지정생성자를 생성하고 그 지정생성자를 편의 생성자 convenience init(name: String)에서 오버라이딩해 사용한다.

이렇게 생성한 RecipeIngredient 클래스는 다음 3가지 형태의 초기자를 이용해 인스턴스를 생성할 수 있다.

let oneMysteryItem = RecipeIngredient()
let oneBacon = RecipeIngredient(name: "Bacon")
let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)

ShoppingListItem는 purchased라는 bool 프로퍼티와 description이라는 계산된 프로퍼티 2가지를 새로 생성한다.

class ShoppingListItem: RecipeIngredient {
    var purchased = false
    var description: String {
        var output = "\(quantity) x \(name)"
        output += purchased ? " ✔" : " ✘"
        return output
    }
}

이제 이 모든 3개의 초기자를 이용해 ShoppingListItem 인스턴스를 생성할 수 있다.

var breakfastList = [
    ShoppingListItem(),
    ShoppingListItem(name: "Bacon"),
    ShoppingListItem(name: "Eggs", quantity: 6),
]
breakfastList[0].name = "Orange juice"
breakfastList[0].purchased = true
for item in breakfastList {
    print(item.description)
}
// 1 x Orange juice ✔
// 1 x Bacon ✘
// 6 x Eggs ✘

실패 가능 생성자 (Failable Initializers)

초기화 과정 중에 실패할 가능성이 있는 생성자를 init뒤에 물음표(?)를 사용해 실패가 가능한 생성자라고 표시할 수 있다.

NOTE❗️
생성자는 이름이 따로 있는 것이 아니라 파라미터로 구분하기 때문에 실패 가능한 초기자와 실패 불가능한 초기자를 같은 파라미터 타입과 이름으로 동시에 사용할 수 없다. 실패 가능한 초기자는 반환값으로 옵셔널 값을 생성한다. 초기화에 실패하는 부분에서 nil을 반환하는 코드를 작성해 초기화가 실패했다는 것을 나타낼 수 있다.

struct Animal {
    let species: String
    init?(species: String) {
        if species.isEmpty { return nil }
        self.species = species
    }
}

열거형에서 사용하는 실패 가능한 생성자 (Failable Initializers for Enumerations)

enum TemperatureUnit {
    case kelvin, celsius, fahrenheit
    init?(symbol: Character) {
        switch symbol {
        case "K":
            self = .kelvin
        case "C":
            self = .celsius
        case "F":
            self = .fahrenheit
        default:
            return nil
        }
    }
}

필수 생성자 (Required Initializers)

모든 서브클래스에서 반드시 구현해야 하는 초기자에는 아래 예제와 같이 required 키워드를 붙여 준다.

class SomeClass {
    required init() {
        // initializer implementation goes here
    }
}

NOTE❗️
필수초기자 표시를 해도 꼭 구현을 할 필요는 없다.

클로저나 함수를 이용해 기본 프로퍼티 값을 설정하기 (Setting a Default Property Value with a Closure or Function)

기본 값 설정이 단순히 값을 할당하는 것이 아니라 다소 복잡한 계산을 필요하다면 클로저나 함수를 이용해 값을 초기화 하는데 이용할 수 있다.

class SomeClass {
    let someProperty: SomeType = {
        // create a default value for someProperty inside this closure
        // someValue must be of the same type as SomeType
        return someValue
    }()
}

someProperty는 클로저가 실행된 후 반환 타입이 SomeType인 SomeValue를 기본 값으로 갖게 된다.

NOTE❗️
클로저를 초기자에서 사용하면 클로저 안에 self나 다른 프로퍼티를 사용할 수 없습니다. 그 이유는 클로저가 실행될 시점에 다른 프로퍼티는 초기화가 다 끝난 것이 아니기 때문이다.