[Swift🦩] #10 프로퍼티

• struct, class, enum 안에 선언할 수 있고, 대체로 특정 타입의 인스턴스이다.
• 그 중 저장 프로퍼티는 struct, class 안에만 선언할 수 있다.
• 프로퍼티 관찰자를 통해 값이 변경되는 것을 모니터링하고, 특정 동작을 수행하게 할 수 있다.

1. Stored Property

저장된 상수, 변수.

struct FixedLengthRange {
    var firstValue: Int
    let length: Int
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3) // 0, 1, 2
rangeOfThreeItems.firstValue = 6 // 6, 7, 8

let rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3) // 0, 1, 2
rangeOfThreeItems.firstValue = 6 // let 으로 선언했기 때문에 불가능.
// 하지만 class 라면? 가능. 
// rangeOfThreeItems = FixedLengthRange(firstRange: 1, elength: 4) 처럼 
// 아예 새로운 변수를 할당하는 것은 불가능.

lazy

사용되기 전까지 초기값이 계산되지 않는 프로퍼티.
초기화 완료 후에도 초기값이 없을 수 있기 때문에 var 로 선언해야 한다. let 으로 선언하는 경우는 초기화 전에 값을 가지고 있어야 해서 lazy 가 불가능.

lazy var tableView: UITableView = {
    let v = UITableView()
    v.register(UITableViewCell.self, reuseIdentifier: "cell")
    v.delegate = self
    v.dataSource = self
    return v
}()

📕 여러 스레드에서 동시에 초기화 되지 않은 lazy 프로퍼티에 접근하게 되면, 여러번 초기화 될 수도 있다.

2. Computed Property ⭐️

값을 실질적으로 저장하지 않고, 다른 프로퍼티의 값을 간접적으로 가져와서 설정. getter, setter

let start = 0
var end = 10
var mid {
    get { return (start + end) / 2 }
    // set(newMid) { end = 2 * newMid }
    set { end = 2 * newValue } // 자동 제공.
}
var readOnlyMid {
    return (start + end) / 2
}

📕 메서드 대신 쓰는 이유 : 직관적이고, 두개나 만들 필요가 없다.
📕 단점? : 쓰기 전용 프로퍼티는 생성할 수 없다.

3. Property Observer ⭐️

프로퍼티의 값이 변경되는지 관찰하고 응답한다.
새로운 값과 현재 값이 같아도 프로퍼티에 값이 설정될 때 호출된다.

• 정의한 저장 프로퍼티
• 상속된 저장 프로퍼티
• 상속된 계산 프로퍼티

에서 추가할 수 있다. (전역 변수와 정의한 계산 프로퍼티에서는 불가능)

• willSet : 값 저장 직전에 호출. (newValue로 저장될 값 사용 가능)
• didSet : 새로운 값이 저장되자마자 호출. (oldValue 로 방금 저장된 값 사용 가능)

주의 : 여기서 자기 자신을 다시 set 해버리면?? 무한 루프가 될 수 있음.

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("About to set totalSteps to \(newTotalSteps)")
        }
        didSet {
            if totalSteps > oldValue  {
                print("Added \(totalSteps - oldValue) steps")
            }
        }
    }
}

+) inout 함수에 willSet, didSet 이 선언된 프로퍼티를 인자로 넘겼을 때, 항상 값이 새로 덮어쓰기되므로 해당 함수가 끝나는 시점에 willSet didSet 이 모두 호출된다.

4. Property Wrapper ⭐️❓

값이 실제로 저장되어 있는 프로퍼티, 값을 관리하는 프로퍼티를 분리하는 방법 중 하나다. 로직이 자주 쓰이고 재사용성이 있다면 이렇게 관리해주자.

• 구조체에 @propertyWrapper 키워드를 붙여서 정의하고,
• 사용할 곳에서 @구조체이름 키워드를 붙여서 사용한다.

@propertyWrapper
struct TwelveOrLess {
    private var number = 0
    // number 에 직접 접근 X, wrappedValue 를 통한 접근만 가능.
    var wrappedValue: Int {
        get { return number }
        set { number = min(newValue, 12) }
    }
}

struct SmallRectangle {
    // 가로 세로가 모두 12 이하인지 확인.
    @TwelveOrLess var height: Int
    @TwelveOrLess var width: Int
}

// 같은 역할을 하는 코드이지만 wrapping 을 이렇게 할수도 있음.
struct SmallRectangle {
    private var _height = TwelveOrLess()
    private var _width = TwelveOrLess()
    var height: Int {
        get { return _height.wrappedValue }
        set { _height.wrappedValue = newValue }
    }
    var width: Int {
        get { return _width.wrappedValue }
        set { _width.wrappedValue = newValue }
    }
}

init for property wrapping

property wrapping 을 사용한 코드에서 초기자를 정의하고, 사용할 수 있다.

@propertyWrapper
struct SmallNumber {
    private var maximum: Int
    private var number: Int

    var wrappedValue: Int {
        get { return number }
        set { number = min(newValue, maximum) }
    }

    init() {
        maximum = 12
        number = 0
    }
    init(wrappedValue: Int) {
        maximum = 12
        number = min(wrappedValue, maximum)
    }
    init(wrappedValue: Int, maximum: Int) {
        self.maximum = maximum
        number = min(wrappedValue, maximum)
    }
}

struct ZeroRectangle {
    @SmallNumber var height: Int // init 사용
    @SmallNumber var width: Int = 1 // init(wrappedValue: ) 사용
    
    // init(wrappedValue:  maximum: ) 사용
    @SmallNumber(wrappedValue: 3, maximum: 10) var height2: Int 
    @SmallNumber(maximum: 9) var width2: Int = 2 
}

var zeroRectangle = ZeroRectangle()
print(zeroRectangle.height, zeroRectangle.width)
// Prints "0 0"

값 투영

저장할 값의 변화를 필요한 값으로 투영하여 사용할 수 있다.

@propertyWrapper
struct SmallNumber {
    private var number: Int
    private(set) var projectedValue: Bool 
    // number 가 큰 값인지에 대한 Bool 값으로 number 를 투영.

    var wrappedValue: Int {
        get { return number }
        set {
            if newValue > 12 {
                number = 12
                projectedValue = true
            } else {
                number = newValue
                projectedValue = false
            }
        }
    }

    init() {
        self.number = 0
        self.projectedValue = false
    }
}

struct SomeStructure {
    @SmallNumber var someNumber: Int
}
var someStructure = SomeStructure()

// $변수명 으로 투영된 변수 값에 접근할 수 있다.
someStructure.someNumber = 4
print(someStructure.$someNumber)
// Prints "false"

someStructure.someNumber = 55
print(someStructure.$someNumber)
// Prints "true"

-> 근데 결국 wrappedValue 에 접근하는 것일 텐데 projectedValue 에는 어떻게 접근하는거지..?? 라고 생각했는데, wrappedValue, projectedValue 라는 키워드 자체가 프로퍼티 래핑에서 제공되는 것.

-> presenter 에서 외부에서는 subject 를 asObservable, asObserver 다루게 하는데, 많이 겹치므로 이 문법을 사용하면 좋을듯.

5. 전역, 지역

• 전역 : 함수, 메서드, 클로저, 또는 타입 컨텍스트 외부에 정의된 변수
• 지역 : 함수, 메서드, 클로저, 또는 타입 컨텍스트 내부에 정의된 변수

전역 상수, 변수는 항상 lazy 로 계산된다.

6. Type Property ⭐️

인스턴스마다 생성되는 프로퍼티와 다르게, 타입 하나에 생성되는 프로퍼티.
기본값을 항상 줘야하고, 기본적으로 lazy 로 동작한다.
📕 하지만, 다중 스레드 환경에서도 여러번 초기화되지 않는다.

저장 / 계산 프로퍼티로 모두 정의 가능
정의하는 문장 앞에 static 키워드를 붙여서 사용한다.

struct UserInfo {
    static var uuid: String {
        return UUID().uuidString
    }
    static var name: String = "초기값"
}

print(UserInfo.uuid)

+) struct 보다는 enum 에서 많이 사용한다. 인스턴스를 만들지 않고 사용하려고. enum 은 초기자가 없으니까!!

📕 모든 인스턴스가 공통으로 사용하는 값에 사용한다.
📕 Stored, Computed 프로퍼티로 정의 가능

7. 키 경로 📕

• 함수 이름을 변수에 참조해서 나중에 사용할 수 있었던 것 처럼,
• 프로퍼티도 복사해오거나 하지 않고, 해당 프로퍼티의 위치만 참조할 수 있다.
• AnyKeyPath 클래스의 WritableKeyPath<Root, Value> (값 타입), ReferenceWritableKeyPath<Root, Value>(참조 타입) 를 사용한다.
• 타입 외부로 공개된 인스턴스 프로퍼티나 서브스크립트에 한해서만 표현 가능하다.

class Person {
    var name: String
    
    init(name: String) {
        self.name = name
    }
}

struct Stuff {
    var name: String
    var owner: Person
}

print(type(of: \Person.name)) // ReferenceWritableKeyPath<Person, String>
print(type(of: \Stuff.name)) // WritableKeyPath<Person, String>


// KeyPath 를 이용하여 값 가져오기.
let ddosang = Person(name: "ddosang")
let xiyeon = Person(name: "xiyeon")
let macbookAir = Stuff(name: "macbook Air", owner: ddosang)

let stuffNameKeyPath = \Stuff.name
let ownerKeyPath = \Stuff.owner
// 경로를 덧붙일 수도 있다.
let ownerNameKeyPath = ownerKeyPath.appending(path: \.name)

print(macbookAir[keyPath: stuffNameKeyPath]) // macbook Air
macbookAir[keyPath: ownerKeyPath] = xiyeon
print(macbookAir[keyPath: ownerNameKeyPath]) // xiyeon

질문

property wrapper에 대해서 설명하시오.

• property 선언, 사용을 따로 구분하기 위한 문법이다.
• private 으로 실제 값을 저장할 변수를 선언하고,
• wrappedValue 에 getter, setter 를 이용해서 변수의 값을 가져오고 설정한다.
• projectedValue 를 사용해서 변수와 관련된 값을 투영해서 가져다 쓸 수 있다.
• 자주 사용하는 패턴에 적용해보는 것이 좋다.

참고
https://bbiguduk.gitbook.io/swift/language-guide-1/properties

야곰의 Swift5 Programming