chapter19.txt

# 19 옵셔널 체인 (Optional Chaining)
> Translator : 허혁 (hyukhur@gmail.com)

옵셔널 체인(Optional chaining)란 nil이 될 수도 있는 옵션(options)을 가진 프로퍼티(property), 메소드(method), 서브 스크립트 (subscript)에 질의하고 호출하는 프로세스를 말한다.  만약 어떤 옵션이 값을 가진다면 프로퍼티, 메소드, 서브스크립트 호출은 성공하고 옵션이 nil이면, 프로퍼티, 메소드, 서브스크립트 호출은 nil을 반환하게 된다.
여러개의 질의도 함께 엮일 수 있으며, 만약 체인(chaining) 중간의 어떤 링크가 nil이라면 조용하게 전체 체인은 실패한다. 

>노트
스위프트(Swift)의 옵셔널 체인이 오브젝티브씨(Objective-C)에 있는 nil에 메시지 보내기와 유사하다. 그러나, 모든 타입(any type)에서 동작하고, 성공, 실패 여부를 확인할 수 있다는 점에서 차이가 있다.

## 강제 랩핑 해제(Forced Unwrapping) 대안으로써 옵셔널 체인
호출하고자 하는 프로퍼티, 메소드, 서브스크립트의 옵셔널 값(optional value)이 nil 아닐 때 옵션값 뒤에 물음표(?)를 두어 옵셔널 체인를 둘 수 있다. 이것은 옵션값 뒤에 느낌표(!)를 두어 그 값을 강제로 랩핑 해제하는 것과 유사하다. 가장 주요한 차이점은 옵셔널 체인는 옵션이 nil일 때 자연스럽게 실패한다는 것이고, 강제 랩핑 해제는 옵션이 nil인 경우 런타임 에러가 발생한다.
옵셔널 체인이 nil 값에도 호출할 수 있다는 사실을 반영하기 위해 옵셔널 체인 호출 결과는 항상 옵션값이다. 비록 질의한 프로퍼티, 메소드, 서브스크립트가 항상 옵션값이 아닌 결과를 도출해도 그렇다. 이 옵션 반환 값을 사용해서 옵셔널 체인 호출이 성공했는지 ( 반환된 옵션이 값을 가지는 ) 체인 중간의 nil 값 ( 옵션 반환값이 nil ) 때문에 실패했는지를  확인할 수 있다.
구체적으로, 옵셔널 체인 호출 결과는 옵션으로 감싸여져 있음에도 기대한 반환값과 동일한 타입이다. 일반적으로 Int를 반환하는 프로퍼티는 옵셔널 체인에 따라 접근이 가능할때는 Int?를 반환할 것이다. 
다은 몇몇 코드 조각은 옵셔널 체인이 어떻게 강제 랩핑 해제와 다르고 성공 여부 확인을 가능케 하는지 보여준다.
먼저 `Person`과 `Residence`라는 클래스를 정의하자.
```
class Person {
    var residence: Residence?
}

class Residence {
    var numberOfRooms = 1
}]
```
`Residence`인스턴스(Instance)는 기본값이 1인 `numberOfRooms`이라는 단 하나의 Int 프로퍼티를 가진다. `Person`인스턴스는 `Residence?`타입으로 `residence`이라는 옵셔널 프로퍼티를 가진다.
만약 `Person`이라는 인스턴스를 새로 만들면, 옵션으로 된 효과에 따라 기본적으로 nil로 설정된다. 아래 코드에서는 `john`는 nil로 된 `residence`프로퍼티를 가질 것이다.
```
let jone = Person()
```
만약 `Person`의 `residence`의 `numberOfRooms`프로퍼티를 그 값을 강제로 랩핑 해제를 하려고 느낌표를 붙여서 접근한다면 런타임 에러(Runtime Error)를 유발시킬 것이다. 왜냐하면 해제할 `residence`값 자체가 없기 때문이다.
```
let roomCount = john.residence.numberOfRooms
```
위 코드는 `john.residence`가 nil이 아닌 값을 성공하며 방 갯수에 적절한 숫자를 담고 있는 Int 값에 `roomCount`를 설정할 것이다. 그러나 이 코드는 위에 보여지는 것처럼 `residence`가 nil이라면 항상 런타임 에러를 유발 시킨다. 
옵셔널 체인은 `numberOfRooms`값에 접근하는데 대안법을 제공한다. 옵셔널 체인을 사용하기 위해 느낌표 자리에 물음표를 사용하면 된다.
```
if let roomCount = john.residence?.numberOfRooms {
    println("John's residence has \(roomCount) room(s).")
} else {
    println("Unable to retrieve the number of rooms.")
}
// prints "Unable to retrieve the number of rooms."
```
이것은 스위프트(swift)가 옵셔널 `residence`프로퍼티를 "묶고" 만약 `residence`가 있으면 `numberOfRooms`값을 가져온다는 것을 말해준다.

`numberOfRoom`에 대한 접근이가 잠제적으로 실패할 수 있기 때문에 옵셔널 체인은 `Int?`이나 "옵션널 `Int`"형 값을 반환하려고 한다. 위 예제처럼 `residence`가 `nil`인 경우는 `numberOfRooms`에 대한 접근이 불가능하다는 사실을 반영하기 위해서 이 옵셔널`Int` 역시 `nil`이 될 것이다.
`numberOfRooms`가 비옵셔널 `Int`임에도 불구하고 참인 것을 명심해라. 옵셔널 체인을 통해 질의한다는 것은 `numberOfRooms`가 `Int` 대신 `Int?`를 항상 반환할 것이라는 것을 의미한다.
`john.residence`에 `Residence` 인스턴스를 할당할 수 있는데 그러면 더이상 `nil`값은 존재하지 않게 된다.
```
john.residence = Residence()
```
`john.residence`는 실체 `Residence`인스턴스를 이제 가지게 되었다. 만약 예전과 동일한 옵셔널 체인을 사용해 접근하려고 하면, 1이라는 `numberOfRooms`기본값을 가지는 `Int?`가 반환될 것이다.
```
if let roomCount = john.residence?.numberOfRooms {
    println("John's residence has \(roomCount) room(s).")
} else {
    println("Unable to retrieve the number of rooms.")
}
// prints "John's residence has 1 room(s)."
```
##옵셔널 체인을 위한 모델(Model) 클래스(Class) 선언

프로퍼티, 메소드, 서브스크립트를 호출하는 것 같은 한단계 더 깊은 옵셔널 체인을 사용할 수 있다. 이는 상호관계있는 타입간의 복잡한 모델에서 서브 프로퍼티(subproperty)를 파고 들 수 있게 해주고 그 서브 프로터티에 프로퍼티와 메소드, 서브스크립트에 접근할 수 있는지 아닌지를 확인할 수 있게 해준다.
다음 코드 조각은 다단계 옵셔널 체인 예를 포함한 몇가지 순차적인 예제에서 사용될 4개의 모델 클래스를 정의한다. 이 클래스들은 위에 나온 `Person`과 `Residence` 모델에 `Room`과 `Address` 클래스를 추가하고 연관 프로퍼티와 메소드, 서브스크립트를 확장한다.
`Person` 클래스는 이전과 동일한 방법으로 정의한다.
```
class Person {
    var residence: Residence?
}
```
`Residence` 클래스는 이전보다 조금 복잡해졌다. 이번에는 `Residence` 클래스에 `Room[]` 타입의 빈 배열로 초기화된 `rooms`라는 변수 프로퍼티를 선언한다.
```
class Residence {
    var rooms = Room[]()
    var numberOfRooms: Int {
    return rooms.count
    }
    subscript(i: Int) -> Room {
        return rooms[i]
    }
    func printNumberOfRooms() {
        println("The number of rooms is \(numberOfRooms)")
    }
    var address: Address?
}
```

이번 버전 `Residence`는 `Room`인스턴스 배열을 저장하기 때문에, 그 `numberOfRooms`프로퍼티는 저장된 프로퍼티가 아닌 계산된 프로퍼티로 구현했다. 계산된 `numberOfRooms`프로퍼티는 단순히 `rooms`배열에서 `count`프로퍼티의 값을 반환한다.
그 `rooms`배열에 접근하기 위한 바로가기로 이번 버전 `Residence`는 읽기만 가능한 서브 스크립트를 제공하는데 서브스크립트에게 전달받는 인덱스(index)가 적합할 것이라는 가정으로 시작해보겠다. 만약 인덱스가 적합하다면, 서브스크립트는 rooms 배열의 요청받은 인덱스의 방정보를 반환할 것이다.
또한 이번 버전 `Residence`는 `printNumberOfRooms`라는 이름의 메소드를 제공하는데 단순히 `Residence`에 방 갯수를 출력한다.
마지막으로 `Residence`에 `Address?`이란 타입으로 `address`라는 옵셔널 프로퍼티를 선언한다. 이를 위한 `Address`클래스 타입은 밑에 정의하겠다.
`rooms`배열에 사용하는 `Room`클래스는 `name`이라는 프로퍼티 하나를 가지는 간단한 클래스인데 이는 적절한 방이름을 설정하기 위한 초기화 역할(initializer)을 한다.
```
class Room {
    let name: String
    init(name: String) { self.name = name }
}
```

이 모델의 마지막 클래스는 `Address`이다. 이 클래스는 `String?`타입의 옵셔널 프로퍼티를 3개 가지고 있다. 그 중 2개는 `buildingName`과 `buildingNumber` 인데 주소를 구성하는 특정 빌딩에 대한 구분을 짓기 위한 대체 수단이다. 3번째 프로퍼티인 `street`는 그 주소의 도로이름에 사용한다.
```
class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if buildingName {
            return buildingName
        } else if buildingNumber {
            return buildingNumber
        } else {
            return nil
        }
    }
}
```
또한 `Address`클래스는 `String?`반환값을 가지는 `buildingIdentifer`이란 이름의 메소드를 제공한다. 이 메소드는 `buildingName`과 `buildingNumber`프로퍼티를 확인해서 만약 `buildingName`이 값을 가진다면 그 값을 혹은 `buildingNumber`이 값을 가진다면 그 값을, 둘다 값이 없다면 `nil`을 반환한다.

## 옵셔널 체인를 통한 프로퍼티 호출
강제 랩핑 해제(Forced Unwrapping) 대안으로써 옵셔널 체인에서 봤던 것처럼 옵셔널 체인을 온션값에 대한 프로퍼티 접근에 접근할 수 있는지 만약 프로퍼티 접근이 가능한지 확인하기 위해 사용할 수 있다. 그러나선택 묶임를 통해 프로퍼티의 값을 설정하는 것은 할 수 없다.
위에 정의한 새로운 `Person` 인스턴스를 사용해 클래스를 만들어 이전처럼 `numberOfRooms` 프로퍼티에 접근하기를 시도해본다.
```
let john = Person()
if let roomCount = john.residence?.numberOfRooms {
    println("John's residence has \(roomCount) room(s).")
} else {
    println("Unable to retrieve the number of rooms.")
}
// prints "Unable to retrieve the number of rooms."
```
`john.residence`가 `nil`이기 때문에 이 옵셔널 체인을 예전과 동일한 방식으로 호출했지만 에러 없이 실패한다.

## 옵셔널 체인을 통한 메소드 호출
옵셔널 체인을 사용해서 옵션값을 호출하고 메소드 호출이 성공했는지 여부를 확인해볼 수 있다. 설렁 메소드가 반환값을 정의하지 않더라고 할 수 있다.
`Residence` 클래스에 있는 `printNumberOfRooms`메소드는 `numberOfRooms`의 현재 값을 출력한다. 그 메소드는 다음과 같을 것이다.
```
func printNumberOfRooms() {
    println("The number of rooms is \(numberOfRooms)")
}
```
이 메소드는 반환값을 명시하지 않았다. 그러나 반환형이 없는 함수와 메소드는 `Functions Without Return Values`에 나와 있는 것처럼 암시적으로 `Void`타입을 반환하게 된다.
만약 옵셔널 체인에 있는 옵션값에 이 메소드를 호출한다면, 메소드 반환형은 `Void`가 아니라 `Void?`이 될 것이다. 옵셔널 체인을 통해 호출될 때 옵셔널 타입은 항상 반환 값을 가지기 때문이다. 이는 메소드가 반환값이 정의되어 있지 않더라도 `printNumberOfRooms`메소드를 호출이 가능한지를 if문을 써서 확인할 수 있게 한다. `printNumberOfRooms`에서 암시적 반환값은 만약 메소드가 옵셔널 체인를 통해 성공적으로 호출되었다면 `Void`와 동일할 것이고 그렇지 않다면 `nil`과 동일할 것이다.
```
if john.residence?.printNumberOfRooms() {
    println("It was possible to print the number of rooms.")
} else {
    println("It was not possible to print the number of rooms.")
}
// prints "It was not possible to print the number of rooms."
```

## 옵셔널 체인를 통한 서브스크립트 호출
옵셔널값에 대한 서브스크립트에서 값을 가져와서 서브스크립트 호출이 성공했는지 확인하기 위해 옵셔널 체인을 사용할 수 있다. 그러나 을 통해 서브스크립트로 값을 설정하는 것은 할 수 없다.

>노트
옵셔널 체인를 통해 옵션값에 대한 서브스크립트를 접근할 때 서브스크립트 꺽은 괄호(bracket) 앞에 물음표를 놓아야 한다. 뒤가 아니다. 옵셔널 체인 물음표는 항상 옵셔널 표현식의 뒤에 바로 따라나와야 한다.

아래 예는 `Residence`클래스에 정의되어 있는 서브스크립트를 사용하는 `john.residence` 프로퍼티의 `rooms`배열에 있는 첫번째 방이름을 집어오려고 하는 것이다. `john.residence`가 현재 `nil`이기 때문에 서브스크립트는 실패한다.
```
if let firstRoomName = john.residence?[0].name {
    println("The first room name is \(firstRoomName).")
} else {
    println("Unable to retrieve the first room name.")
}
// prints "Unable to retrieve the first room name."
```

이 서브스크립트 호출 속에 있는 옵셔널 체인 물음표는 `john.residence`바로 뒤, 서브스크립트 꺽은 괄호 전에 존재해야한다. 왜냐하면, `john.residence`가 옵셔널 체인을 꾀할 옵션값이기 때문이다.
만약, `john.residence`에 `rooms`배열에 한개 이상의 `Room`인스턴스도 같이 실제 `Residence`를 만들어서 할당한다면 옵셔널 체인을 통해 `rooms`배열안의 실제 아이템에 접근하기 위해서 `Residence`서브스크립트를 사용할 수 있다. 
```
let johnsHouse = Residence()
johnsHouse.rooms += Room(name: "Living Room")
johnsHouse.rooms += Room(name: "Kitchen")
john.residence = johnsHouse
if let firstRoomName = john.residence?[0].name {
    println("The first room name is \(firstRoomName).")
} else {
    println("Unable to retrieve the first room name.")
}
// prints "The first room name is Living Room."
```
## 다단계 묶임 연결하기
프로퍼티와 메소드, 서브스크립트를 사용해 모델 깊이 파고들기 위해서 옵셔널 체인을 여러 단계로 함께 엮을 수 있다. 그러나 다단계 옵셔널 체인으로 반환값에 더 많은 옵셔널 단계를 넣을 수는 없다.
다른 방식으로:
- 만약 집어오려고 하는 타입이 옵셔널이지 않으면, 옵셔널 체인으로 인해 옵셔널로 변경될 것이다.
- 만약 집어오려고 하는 타입이 이미 옵셔널이라면, 옵셔널 체인으로 인해 더 옵셔널로 변경되지는 않을 것이다.
그러므로:
- `Int`타입을 옵셔널 체인을 통해 집어오려고 하면, 항상 `Int?`가 반환될 것이다. 얼마나 많은 단계의 체인이 사용되었는지는 중요하지 않다.
- 유사하게, `Int?`값을 집어오려고 하면, 항상 `Int?`가 반환될 것이다.  얼마나 많은 단계의 체인이 사용되었는지는 중요하지 않다.
아래 예는 `john`의 `residence`프로퍼티의 `address`프로퍼티의 `street`프로퍼티에 접근하려는 것을 보여준다. 여기에 사용되는 2개의 옵셔널 체인 단계가 있는데 `residence`와 `address`로 둘은 엮여 있고 둘다 옵셔널타입이다.
```
if let johnsStreet = john.residence?.address?.street {
    println("John's street name is \(johnsStreet).")
} else {
    println("Unable to retrieve the address.")
}
// prints "Unable to retrieve the address."
```
`john.residence`의 값은 현재 적합한 `Residence`인스턴스를 포함하고 있다. 그러나 `john.residence.address`의 값은 현재 `nil`이다. 이때문에, `john.residence?.address?.street`호출은 실패한다.
위 예제를 잘 생각해보자. `street`프로퍼티 값을 집어오고자 했다. 이 프로퍼티는 `String?`이다. 그러므로  `john.residence?.address?.street`의 반환값 역시 두단계 옵셔널 체인으로 프로퍼티가 옵셔널타입에 추가로 더해 적용되었음에도 불구하고 `String?`이다.
만약 `john.residence.address`의 값으로써 실제 `Address`인스턴스를 설정하고 그 `Adress`의 `street`프로퍼티에 실제 값을 설정한다면, 다단계 옵셔널 체인을 통해 그 프로퍼티 값을 접근할 수 있을 것이다.
```
let johnsAddress = Address()
johnsAddress.buildingName = "The Larches"
johnsAddress.street = "Laurel Street"
john.residence!.address = johnsAddress
if let johnsStreet = john.residence?.address?.street {
    println("John's street name is \(johnsStreet).")
} else {
    println("Unable to retrieve the address.")
}
// prints "John's street name is Laurel Street."
```
`john.residence.address`의 `address`인스턴스에 할당하기 위해서 느낌표를 사용한 것을 잘보자. `john.residence`프로퍼티는 옵셔널타입을 가지기에 `Residence`의 `address`프로퍼티에 접근하기 전에 느낌표를 사용해서 그 실제 값을 까볼 필요가 있다.

## 옵셔널 반환값을 사용해서 메소드 체인
이전 예제는 옵셔널 체인을 사용해서 옵셔널타입의 프로퍼티의 값을 어떻게 집어오는지 보여주었다. 또한 옵셔널 체인을 사용해서 옵셔널타입 값을 반환하는 메소드를 호출하고 필요하다면 그 메소드의 반환값을 연결할 수 있었다.
아래 예제는 옵셔널 체인을 통해 Address 클래스의 buildingIndentifer 메소드를 호출한다. 이 메소드는 String? 타입의 값을 반환한다. 이전에 설명한데로, 옵셔널 체인에 따라 호출된 메소드의 최종 반환값 또한 String?이 된다.
```
if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
    println("John's building identifier is \(buildingIdentifier).")
}
// prints "John's building identifier is The Larches."
```
만약 이 메소드 반환값 이상의 옵셔널 체인을 실행하기 원한다면, 메소드 둥근 괄호(parentheses) 다 음옵셔널 체인음 물음표를 두면 된다.
```
if let upper = john.residence?.address?.buildingIdentifier()?.uppercaseString {
    println("John's uppercase building identifier is \(upper).")
}
// prints "John's uppercase building identifier is THE LARCHES."  
```  
>노트
위 예제에서 둥근 괄호 다음에 옵셔널 체인 물음표를 놓았는데, 묶고자 하는 옵션값이 buildingIndentifer 자체가 아니라 buildingIndentifer 메소드의 반환값이기 때문이다.