Swift 공식 문서 정리 - 프로퍼티 (Properties)

안녕하세요. 지난 포스팅에 이어 오늘은 **프로퍼티(Properties)**에 대해 알아보겠습니다. 프로퍼티는 클래스, 구조체, 열거형에서 값을 저장하고 계산하는 방법을 제공하는 Swift의 중요한 구성 요소입니다.

📌 프로퍼티란?

프로퍼티는 특정 클래스, 구조체, 또는 열거형과 연결된 값입니다. Swift에서는 다양한 종류의 프로퍼티를 지원합니다:

• 저장된 프로퍼티(Stored Properties): 인스턴스의 일부로 값을 저장
• 계산된 프로퍼티(Computed Properties): 값을 저장하지 않고 계산
• 타입 프로퍼티(Type Properties): 타입 자체에 속하는 프로퍼티
• 프로퍼티 관찰자(Property Observers): 프로퍼티 값 변화를 관찰
• 프로퍼티 래퍼(Property Wrappers): 프로퍼티 코드를 재사용

📌 저장된 프로퍼티 (Stored Properties)

저장된 프로퍼티는 가장 기본적인 형태의 프로퍼티로, 클래스나 구조체 인스턴스의 일부로 상수나 변수 값을 저장합니다.

struct FixedLengthRange {
    var firstValue: Int  // 변수 저장 프로퍼티
    let length: Int      // 상수 저장 프로퍼티
}

var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
rangeOfThreeItems.firstValue = 6  // 값 변경 가능
// rangeOfThreeItems.length = 4   // 에러! 상수 프로퍼티는 변경 불가

저장된 프로퍼티(Stored Property): 인스턴스의 일부로 값을 저장하는 변수나 상수입니다.

구조체와 상수

구조체는 값 타입이므로, 구조체 인스턴스를 상수로 선언하면 그 안의 모든 프로퍼티(변수 프로퍼티 포함)도 변경할 수 없게 됩니다.

let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// rangeOfFourItems.firstValue = 6  // 에러! 구조체가 상수이므로 변경 불가

값 타입과 참조 타입의 차이: 구조체는 값 타입으로, 상수로 선언 시 모든 프로퍼티가 불변이 됩니다. 반면 클래스는 참조 타입으로, 상수로 선언해도 변수 프로퍼티는 변경 가능합니다.

지연 저장된 프로퍼티 (Lazy Stored Properties)

지연 저장된 프로퍼티는 처음 사용될 때까지 초기값이 계산되지 않는 프로퍼티입니다. 초기화 비용이 큰 리소스나 설정에 유용합니다.

class DataImporter {
    // 초기화에 시간이 많이 걸린다고 가정
    var filename = "data.txt"
}

class DataManager {
    lazy var importer = DataImporter()  // 처음 사용될 때까지 생성되지 않음
    var data = [String]()
}

let manager = DataManager()
// 아직 importer는 생성되지 않음
manager.data.append("Some data")
// importer 프로퍼티에 처음 접근할 때 DataImporter 인스턴스가 생성됨
print(manager.importer.filename)  // "data.txt"

지연 프로퍼티(Lazy Property): lazy 키워드로 선언되며, 처음 접근할 때까지 초기화되지 않습니다. 반드시 변수(var)로 선언해야 합니다.

📌 계산된 프로퍼티 (Computed Properties)

계산된 프로퍼티는 실제 값을 저장하지 않고, getter와 setter를 통해 다른 프로퍼티를 기반으로 값을 계산합니다.

struct Point {
    var x = 0.0, y = 0.0
}

struct Size {
    var width = 0.0, height = 0.0
}

struct Rect {
    var origin = Point()
    var size = Size()

    // 계산된 프로퍼티
    var center: Point {
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set(newCenter) {
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
    }
}

var square = Rect(origin: Point(x: 0.0, y: 0.0), size: Size(width: 10.0, height: 10.0))
print(square.center)  // Point(x: 5.0, y: 5.0)
square.center = Point(x: 15.0, y: 15.0)
print(square.origin)  // Point(x: 10.0, y: 10.0)

계산된 프로퍼티(Computed Property): 실제 값을 저장하지 않고 getter와 setter를 통해 값을 계산합니다. 항상 var로 선언합니다.

간소화된 Getter 선언

계산된 프로퍼티의 getter가 단일 표현식으로 구성되면, return 키워드를 생략할 수 있습니다.

struct CompactRect {
    var origin = Point()
    var size = Size()

    var center: Point {
        get {
            Point(x: origin.x + (size.width / 2),
                  y: origin.y + (size.height / 2))
        }
        set {
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.y - (size.height / 2)
        }
    }
}

읽기 전용 계산된 프로퍼티

setter 없이 getter만 구현하면 읽기 전용 계산된 프로퍼티가 됩니다. get 키워드와 중괄호를 생략할 수도 있습니다.

struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0

    // 읽기 전용 계산된 프로퍼티
    var volume: Double {
        return width * height * depth
    }
}

let cuboid = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
print(cuboid.volume)  // 40.0

읽기 전용 계산된 프로퍼티: setter 없이 getter만 가진 계산된 프로퍼티입니다. get 키워드와 중괄호를 생략하여 더 간결하게 작성할 수 있습니다.

📌 프로퍼티 관찰자 (Property Observers)

프로퍼티 관찰자는 프로퍼티 값의 변화를 관찰하고 응답합니다. willSet과 didSet 두 가지 관찰자를 제공합니다.

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("곧 totalSteps가 \(newTotalSteps)로 변경됩니다.")
        }
        didSet {
            if totalSteps > oldValue {
                print("\(totalSteps - oldValue)걸음 추가됨")
            }
        }
    }
}

let stepCounter = StepCounter()
stepCounter.totalSteps = 200
// 출력: "곧 totalSteps가 200로 변경됩니다."
// 출력: "200걸음 추가됨"

stepCounter.totalSteps = 360
// 출력: "곧 totalSteps가 360로 변경됩니다."
// 출력: "160걸음 추가됨"

willSet: 값이 저장되기 직전에 호출됩니다. 새 값이 newValue(또는 사용자 지정 매개변수 이름)로 제공됩니다.

didSet: 새 값이 저장된 직후 호출됩니다. 이전 값이 oldValue로 제공됩니다.

📌 프로퍼티 래퍼 (Property Wrappers)

프로퍼티 래퍼는 프로퍼티 코드의 재사용성을 높이고 속성에 대한 관리 코드를 캡슐화합니다.

@propertyWrapper
struct TwelveOrLess {
    private var number = 0

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

struct SmallRectangle {
    @TwelveOrLess var height: Int
    @TwelveOrLess var width: Int
}

var rectangle = SmallRectangle()
rectangle.height = 10  // 정상 설정
rectangle.width = 24   // 12로 제한됨
print(rectangle.height, rectangle.width)  // 10 12

프로퍼티 래퍼(Property Wrapper): @propertyWrapper 속성으로 정의되며, 여러 프로퍼티에 대한 코드 중복을 줄이고 관리 로직을 재사용할 수 있게 합니다.

프로퍼티 래퍼 초기값 설정

프로퍼티 래퍼는 초기화 구문을 통해 추가 설정을 제공할 수 있습니다.

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

// 초기화 방법 1: 기본 초기화
struct ZeroRectangle {
    @SmallNumber var height: Int
    @SmallNumber var width: Int
}

// 초기화 방법 2: 초기값 지정
struct UnitRectangle {
    @SmallNumber var height: Int = 1
    @SmallNumber var width: Int = 1
}

// 초기화 방법 3: 추가 매개변수 제공
struct NarrowRectangle {
    @SmallNumber(wrappedValue: 2, maximum: 5) var height: Int
    @SmallNumber(wrappedValue: 3, maximum: 4) var width: Int
}

let narrowRect = NarrowRectangle()
print(narrowRect.height, narrowRect.width)  // 2 3

투영된 값 (Projected Value)

프로퍼티 래퍼는 projectedValue 프로퍼티를 통해 추가 정보를 노출할 수 있습니다.

@propertyWrapper
struct SmallNumber {
    private var number: Int
    private(set) var projectedValue: Bool

    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 someStruct = SomeStructure()
someStruct.someNumber = 4
print(someStruct.$someNumber)  // false - 값이 제한되지 않음

someStruct.someNumber = 55
print(someStruct.$someNumber)  // true - 값이 12로 제한됨

투영된 값(Projected Value): 프로퍼티 래퍼가 추가 정보를 노출하는 방법입니다. $ 접두사를 사용하여 접근합니다.

📌 타입 프로퍼티 (Type Properties)

타입 프로퍼티는 인스턴스가 아닌 타입 자체에 속하는 프로퍼티입니다. 모든 인스턴스가 공유하는 값을 저장하는 데 유용합니다.

struct AudioChannel {
    // 타입 프로퍼티
    static let thresholdLevel = 10
    static var maxInputLevelForAllChannels = 0

    // 인스턴스 프로퍼티
    var currentLevel: Int = 0 {
        didSet {
            // 최대 임계값 제한
            if currentLevel > AudioChannel.thresholdLevel {
                currentLevel = AudioChannel.thresholdLevel
            }
            // 최대 입력 레벨 업데이트
            if currentLevel > AudioChannel.maxInputLevelForAllChannels {
                AudioChannel.maxInputLevelForAllChannels = currentLevel
            }
        }
    }
}

var leftChannel = AudioChannel()
var rightChannel = AudioChannel()

leftChannel.currentLevel = 7
print(AudioChannel.maxInputLevelForAllChannels)  // 7

rightChannel.currentLevel = 11  // 10으로 제한됨
print(AudioChannel.maxInputLevelForAllChannels)  // 10

타입 프로퍼티(Type Property): static 키워드로 선언되며, 인스턴스가 아닌 타입 자체에 속합니다. 모든 인스턴스가 공유하는 값을 정의할 때 유용합니다.

클래스에서의 타입 프로퍼티: 클래스에서는 static뿐만 아니라 class 키워드를 사용할 수 있으며, class 키워드는 하위 클래스에서 재정의 가능한 타입 프로퍼티를 만듭니다.

📌 전역 및 지역 변수

Swift에서는 프로퍼티와 유사하게 전역 및 지역 변수에도 계산된 변수나 관찰자를 추가할 수 있습니다.

// 전역 계산 변수
var globalComputedValue: Int {
    return 42
}

func someFunction() {
    // 지역 변수에 프로퍼티 래퍼 적용
    @SmallNumber var localNumber: Int = 0

    localNumber = 10  // 정상 설정
    localNumber = 24  // 12로 제한됨
    print(localNumber)  // 12
}

전역 변수(Global Variable): 함수, 메서드, 클로저, 타입 컨텍스트 외부에 정의된 변수입니다.

지역 변수(Local Variable): 함수, 메서드, 클로저 내부에 정의된 변수입니다.

---

요약

Swift의 프로퍼티 시스템은 강력하고 유연합니다. 단순한 값 저장부터 계산, 관찰, 타입별 공유 값까지 다양한 기능을 제공합니다.

• 저장된 프로퍼티는 값을 직접 저장하며, lazy 키워드로 지연 초기화가 가능합니다.
• 계산된 프로퍼티는 값을 저장하지 않고 다른 프로퍼티를 기반으로 계산합니다.
• 프로퍼티 관찰자로 값 변화를 감지하고 대응할 수 있습니다.
• 프로퍼티 래퍼는 프로퍼티 관리 코드를 재사용 가능하게 합니다.
• 타입 프로퍼티는 모든 인스턴스가 공유하는 값을 정의합니다.

이러한 다양한 프로퍼티 유형을 적절히 활용하면 Swift로 더 효율적이고 안전한 코드를 작성할 수 있습니다.