[Swift] 공식 문서 정리 (10) - Properties (저장 프로퍼티, 계산 프로퍼티, 타입 프로퍼티, 옵저버, wrapper)

안녕하세요, 감자입니다. 오늘은 property에 대해서 공부해보았습니다. 프로퍼티 개념을 공부하면서 참 모호하고 이해가 가지 않았던 부분이 많았는데요, 이런 부분에 대해서는 추후에 프로퍼티 정복하기 포스팅을 다시 한 번 해야할 것 같아요. 일단 기초개념을 잡은 정리글 정도로 봐주세요! 시작합니다.

Swift Document chap.10 Properties 바로가기

Properties — The Swift Programming Language (Swift 5.6)

 

---

Properties (프로퍼티)

클래스나 구조체, 열거체의 객체 인스턴스가 그 내부에 가지고 있는 객체의 상태에 관한 정보를 말한다.

프로퍼티 종류

• Stored Property (저장프로퍼티)
  • 인스턴스의 일부분으로써 상수와 변수 값을 저장함
  • 클래스와 구조체에서만 제공함
• Computed Property (계산 프로퍼티)
  • 값을 계산하는데 쓰이는 프로퍼티
  • 클래스, 구조체, 열거형에서 제공함
• Type Property (타입 프로퍼티)
  • 프로퍼티는 타입 그 자체와 연결되어 있을 수 있는데, 이를 타입프로퍼티라고 함

Property Observer (프로퍼티 옵저버)

• 프로퍼티가 가진 값의 변화를 관찰하기 위함
• 정의한 프로퍼티나 하위 클래스가 상속받는 상위클래스에 추가할 수 있다.

Property Wrapper

• 프로퍼티 wrapper를 사용하면 프로퍼티의 getter, setter를 사용하여 코드를 재사용할 수 있음.

---

 

Stored Properties (저장 프로퍼티)

클래스나 구조체의 인스턴스의 일부가 되는 상수나 변수이다. let으로 선언되었냐 var로 선언 되었냐에 따라 상수, 변수 중 어떤 것으로 선언 되었는지 정의된다.

또한 저장 프로퍼티를 선언할때 저장할 “기본값 (Default Property Value)”를 줄 수 있다. 그리고 이러한 저장 프로퍼티는 initializer(생성자)로 초기화 시킬 수 도 있다. 생성자에 의해 초기화 될 때는 해당 프로퍼티가 상수로 선언 되었다고 해도 수정이 가능하다.

struct FixedLengthRange {
  var firstValue: Int
	let length: Int
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
// 이 범위는 정수 값 0, 1, 2 를 나타냄
rangeOfThreeItems.firstValue = 6
// 이제 범위는 정수 값 6, 7, 8 을 나타냄

위 코드는 생성 후에는 길이를 바꿀 수 없는 length 상수를 포함한 구조체이다.

 

Stored Properties of Constant Structure Instances

구조체 인스턴스를 상수로 정의했다면, 생성과 동시에 어떤 프로퍼티도 값을 변경할 수 없게 된다.

let rangeOfFourItems = FixedLengthRange(firstValue : 0, length: 4)
// 이 범위는 정수 값 0, 1, 2, 3 을 나타냄

rangeOfFourItems.firstValue = 6. 
//ERROR!!!!
// 이는, firstValue 가 변수 속성일지라도, 에러를 보고할 것임

위 코드를 보면, firstValue라는 프로퍼티는 구조체를 선언할 때 변수로 선언되었지만, 구조체 인스턴스인 rangeOfFourItems 는 상수로 선언되었기 때문에 rangeOfFourItems는 변경할 수 없게 된다. 이러한 결과가 나오는 이유는 구조체가 값타입 이기 때문이다. 구조체 인스턴스를 상수로 선언하게 되면 내부의 프로퍼티들도 모두 상수가 되어 수정할 수 없게 된다.

 

하지만, 참조타입인 클래스에서는 이것과 다른 결과가 나타난다. 클래스 인스턴스를 상수로 선언해도 선언한 프로퍼티의 값은 변경할 수 있다.

class FixedLengthRange {
	var firstValue: Int 
	let length: Int 

	init(firstValue: Int, length: Int) { 
		self.firstValue = firstValue 
		self.length = length 
	} 
} 

let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// 상수로 선언된 클래스 인스턴스는 변수로 선언된 프로퍼티의 값을 바꿀 수 있습니다. 

rangeOfFourItems.firstValue = 5 
// 오류 발생! rangeOfFourItems.length = 3

 

Lazy Stored Properties

Lazy 저장 프로퍼티는 한마디로 말해서, 값이 사용되기 전까지는 값이 계산되지 않는 프로퍼티 이다. 이 프로퍼티는 lazy라는 키워드를 사용해서 선언할 수 있다. lazy 프로퍼티는 반드시 var 변수로 선언해야한다. 변수로 선언하지 않게 되면 처음 사용할 때까지 값이 없게 되기 때문에 오류가 발생하게 되는 것이다.

 

언제 사용하면 되냐?

lazy 저장 프로퍼티는 초기값이 인스턴스 초기화가 될 때까지 값을 모르는 외부요소에 의존하는 경우에 유용하게 사용된다. 또한, 초기값이 복잡하거나, 계산비용이 많이 드는 설정을 필요로 할 때도 유용하게 사용된다.

class DataImporter {
  /*
  DataImporter 는 외부 파일에서 자료를 불러오는 클래스입니다.
  이 클래스의 초기화에는 유의미한 양의 시간이 걸린다고 가정합니다.
  */
  var filename = "data.txt"
  // DataImporter 클래스는 여기서 자료 불러오는 기능을 제공할 것임
}

class DataManager {
  lazy var importer = DataImporter()
  var data = [String]()
  // DataManager 클래스는 여기서 자료 관리 기능을 제공할 것임
}

let manager = DataManager()
// DataManager의 인스턴스를 만듦.
// 참고로, DataManager의 저장프로퍼티들은 초기값이 있으므로 init이 없어도 됨

manager.data.append("Some data")
manager.data.append("Some more data")
// 하지만 아직도 importer 속성의 DataImporter 인스턴스는 아직 생성하지 않음
// -> lazy 이기 때문

위 코드에서 importer 라는 DataImporter 인스턴스는 lazy 선언이 되었다. 하지만 밖에서 manage라는 Datamanager의 인스턴스를 이용해 importer에 한번도 접근을 하지 않았다. lazy로 선언하지 않았다면, importer가 생성이 되었겠지만, lazy로 선언되었기 때문에 사용되기 전까지는 생성하지 않는 것이다.

 

Stored Properties and Instance Variables

Objective-C 언어에서는 값을 저장하기 위해 점 연산자(instance.property = value)나 set연산자(instance.setProperty(value))으로 값을 저장한다. 뿐만 아니라 메모리 관리와 관련한 개념도 프로퍼티에 함께 명시한다. (@property (nonatomic, retain) NSString*propertyName;)

Swift에서는 이런 컨셉을 하나의 프로퍼티에 녹여 선언과 사용의 혼란을 줄였다. 프로퍼티의 이름, 타입, 메모리관리 등의 모든 정보를 프로퍼티를 선언하는 한 곳에서 정의하게 된다!

---

 

 

Computed Properties (연산 프로퍼티)

클래스, 구조체, 열거형은 계산된 프로퍼티를 선언할 수 있다. 이 연산프로퍼티는 실제 값을 저장하고 있는 것이 아니라, getter과 optional한 setter를 제공해 값을 탐색하고 간접적으로 다른 프로퍼티 값을 설정할 수 있는 방법을 제공한다. 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))
let initialSquareCenter = square.center
square.center = Point(x: 15.0, y: 15.0)
print("square.origin is now at (\\(square.origin.x), \\(square.origin.y))")
// "square.origin is now at (10.0, 10.0)" 를 인쇄함

위 코드는 좌표와크기를 갖는 사각형을 표현하는 구조체에 관한 코드이다. 여기서 Rect 구조체는 사각형의 중점을 표현하는 center라는 연산 프로퍼티를 제공한다. 이 프로퍼티는 계산된 프로퍼티의 정의대로 값을 직접 갖고 있는 것이 아니라 다른 좌표와 크기 프로퍼티들을 적절히 연산해서 구할 수 있다. (get) 또 set으로 사각형의 중점을 직접 설정할 수 있는데, 이 값을 설정할 때 x, y 좌표가 어떤 값을 가져야하는지 x, y에 적절한 좌표값을 넣어준다.

▶ 코드설명

• 다음으로 square.center 을 통해 square 변수의 center 프로퍼티에 접근하는데, 이는 center의 getter을 호출하여 현재 속성값을 가져온다. 기존 값을 반환한다기 보다는, 새 Point를 계산하여 반환해준다. 위코드에서 보면, getter는 (5,5)라는 중심점을 반환한다.
• 그 다음, center 프로퍼티에 (15, 15)라는 새로운 값을 설정했다. 이는 정사각형을 오른쪽 위, 아래 그림에서는 오렌지색 정사각형의 위치로 이동시킨다. center 프로퍼티를 설정하면 center의 setter을 호출하는데 이는 orgin이라는 저장 프로퍼티의 x와 y값을 수정하여 정사각형을 새 위치로 이동시킨다.
• square 라는 새로운 Rect 변수를 생성했다. square변수는 (0,0) 이라는 원점과, (10, 10)이라는 폭과 높이로 초기화된다. 아래 그림의 파란색 사각형이 이 사각형이다.

스위프트 공식 문서 chap.10 프로퍼티

Shorted Setter Declaration (Setter 선언의 간략한 표현)

앞의 코드에서는 Setter의 인자 이름을 아래와 같이 set(newCenter)라고 명시했지만, 만약 이렇게 newCenter라고 인자 이름을 정하지 않으면 인자 기본 이름인 newValue를 사용할 수 있다.

struct AlternativeRect {
  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 {
      origin.x = newValue.x - (size.width / 2)
      origin.y = newValue.y - (size.height / 2)
    }
  }
}

위 코드에서 set 메서드 안에서 인자 이름을 지정하지 않았는데도 newValue.x, newValue.y를 사용할 수 있다는 것을 볼 수 있다.

 

Shorthand Getter Declaration

전체 getter 본문이 단일 표현식이면, getter은 암시적으로 그 표현식을 반환한다.

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

getter에서 return을 생략했다. 이는 함수에서 return을 생략하는 것과 동일한 규칙을 갖는다.

 

Read-Only Computed Properties

getter만 있고 setter를 제공하지 않는 연산 프로퍼티를 읽기전용 프로퍼티라고 한다. 즉, 읽기전용 연산 프로퍼티는 반드시 반환값을 제공하고 다른값을 지정할 수 없는 프로퍼티이다.

▶ Note

• 읽기전용 연산 프로퍼티를 포함하여 연산프로퍼티를 선언할 때는 반드시 let이 아니라 var로 선언해주어야 한다. 보통 읽기 전용이라 함은 한번 값이 정해지면 변하지 않기 때문에 let으로 선언하는 것이 맞으나, 연산 프로퍼티는 읽기전용이라 하더라도 계산값에 따라 값이 변할 수 있기 때문이다. 그래서 꼭 var로 변수를 선언해야한다!

struct Cuboid {
  var width = 0.0, height = 0.0, depth = 0.0
  var volume: Double {
    return width * height * depth
  }
}
let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
print("the volume of fourByFiveByTwo is \\(fourByFiveByTwo.volume)")
// "the volume of fourByFiveByTwo is 40.0" 를 인쇄함

▶  코드설명

• width, height, depth 속성으로 3차원 직사각형 속성을 나타내는 Cuboid 구조체
• 이 구조체는 직육면체의 현재 부피를 계산하여 반환하는 volume이라는 읽기 전용 연산 프로퍼티를 가짐
• 현재 계산한 부피를 외부 사용자가 발견할 수 있도록 Cuboid 가 읽기전용 프로퍼티를 제공함

---

 

Property Observer

프로퍼티 옵저버는 새 값이 설정(set)될 때마다 해당 이벤트를 감지할 수 있게하는 기능이다.

• 프로퍼티 옵저버는 새 값이 이전 값과 같더라도 항상 호출된다.
• lazy 저장 프로퍼티에서는 사용할 수 없다
• sub class의 프로퍼티에 옵저버를 정의하는 것은 가능하다
• 연산 프로퍼티에서는!! setter 에서 값의 변화를 감지할 수 있기 때문에 따로 옵저버를 정의할 필요가 없다.

▶️ willSet

값이 저장되기 바로 직전에 호출 됨

willSet에서는 새 값의 파라미터 명을 지정할 수 있는데, 지정하지 않으면 기본값으로 newValue를 사용한다.

▶️ didSet

새 값이 저장되고 난 직후에 호출 됨

didSet에서는 바뀌기 전의 값의 파라미터명을 지정할 수 있는데 지정하지 않으면 oldValue를 사용한다.

▶ Note

• 서브클래스에서 특정 파라미터의 값을 설정했을 때, 슈퍼클래스의 initializer가 호출 된 후, willSet, didSet 프로퍼티 옵저버가 실행된다. 슈퍼클래스에서 프로퍼티를 변경하는 것도 마찬가지로 슈퍼클래스의 initializer가 호출된 후 옵저버가 실행된다.

 

class StepCounter {
  var totalSteps: Int = 0 {
    willSet(newTotalSteps) {
      print("About to set totalSteps to \\(newTotalSteps)")
    }
    didSet {
      if totalSteps > oldValue  {
        print("Added \\(totalSteps - oldValue) steps")
      }
    }
  }
}
let stepCounter=StepCounter()
stepCounter.totalSteps= 200
// totalSteps 를 200 으로 설정하려고 함
//200 걸음을 추가함

stepCounter.totalSteps= 360
// totalSteps 를 360 으로 설정하려고 함
// 160 걸음을 추가함

stepCounter.totalSteps= 896
// totalSteps 를 896 으로 설정하려고 함
// 536 걸음을 추가함

프로퍼티 옵저버 willSet과 didSet을 사용했다. willSet에서는 새로운 값의 파라미터명으로 newTotalSteps를 지정해서 사용했고, didSet에서는 변하기 전의 값을 의미하는 파라미터명을 지정하지 않고 oldValue라는 기본 파라미터명을 이용했다.

▶ 코드 설명

• willSet은 새로 다가올 값으로, newTotalSteps 라는 사용자 정의 매개변수 이름을 사용했고 이 예제에서는 설정하려는 값을 단순히 인쇄해준다.
• totalStep값을 갱신 한 후, didSet이 호출됨. totalSteps 값과 예전 값을 비교해서 총 걸음 수가 증가했으면, 새 걸음 수가 얼마인지 표시하고자 메시지를 인쇄함.
• didSet은 예전 값에 사용자 정의 매개변수 이름을 제공하지 않고 oldValue라는 이름을 사용함.

---

 

Property Wrappers

Property Wrapper 는 프로퍼티가 저장되는 방식을 관리하는 코드와 프로퍼티를 정의하는 코드 사이에 분리 계층을 추가하는 것이다.

언제 사용하냐?

• Thread-safe한 프로퍼티 또는 값을 DB에 저장하는 프로퍼티가 여러 개 필요할 때
  • 지금까지는 이럴 때 thread-safe 처리, DB 커넥션 처리 등을 위한 코드를 각각의 프로퍼티에 모두 작성해주어야 했음.
  • Property wrapper 를 사용하게 되면 이런 코드 (값 저장을 관리하는 코드)들을 Property wrapper를 정의하는 부분에서 최초 한 번만 작성하면 됨.
  • 그 후 필요한 프로퍼티들에서 이 wrapper를 가져다 적용함으로써 하나의 코드를 재사용할 수 있게 됨.

Property wrapper 사용을 위해서는 구조체, 클래스, 열거형에서 wrapperValue라고 하는 프로퍼티를 선언해야한다. 예시를 보자.

@propertyWrapper
struct TwelveOrLess {
  private var number: Int
  init() { self.number = 0 }
  var wrappedValue: Int {
    get { return number }
    set { number = min(newValue, 12) }
  }
}

위 코드에서는 TwelveOrLess 구조체는 wrappedValue에 항상 12보다 작은 값이 저장되게 만드는 코드이다. 만약 12보다 큰 수라면, 12를 저장하게 만든다. 위에서 선언한 TwelveOrLess 구조체를 사용하여 다른 구조체를 만들면 아래와 같다.

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

var rectangle = SmallRectangle()
print(rectangle.height)
// "0" 을 인쇄함

rectangle.height = 10
print(rectangle.height)
// "10" 을 인쇄함

rectangle.height = 24
print(rectangle.height)
// "12" 를 인쇄함

위 코드처럼 다른 구조체의 프로퍼티에 Property wrapper를 여러번 재사용하여 사용할 수 있다. Property wrapper를 사용하기 위해서는 Property Wrapper의 이름을 @를 함께 써주면 된다. SmallRectangle의 height, width 프로퍼티는 Property wrapper 가 적용된 상태이기 때문에 12이상의 값을 가질 수 없게 된다.

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

위와 Property Wrapper를 사용하게 되면 property wrapper로 선언된 프로퍼티에 값을 저장해야하기 때문에 getter, setter를 사용할 수 있게 된다.

 

Setting Initial Values for Wrapped Properties

위에 작성된 코드는 property wrapper에서 초기값을 정의할 수 있었다. 그러기 때문에 래핑된 프로퍼티는 다른 초기값을 지정할 수 없었는데, 이러한 점을 보완하기 위해서는 property wrapper에 생성자를 추가해주면 된다.

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

위의 코드에서 property wrapper로 사용될 구조체에는 3개의 생성자가 있다. 이렇게 생성자가 추가된 property wrapper를 적용한 예를 살펴보자.

 

struct ZeroRectangle {
  @SmallNumber var height: Int
  @SmallNumber var width: Int
}

var zeroRectangle = ZeroRectangle()
print(zeroRectangle.height, zeroRectangle.width)
// "0 0" 를 인쇄함

이젠 생정자를 통해서 초기 값을 선언할 수 있게 된 것을 볼 수 있습니다.

struct UnitRectangle {
  @SmallNumber var height: Int = 1
  @SmallNumber var width: Int = 1
}

var unitRectangle = UnitRectangle()
print(unitRectangle.height, unitRectangle.width)
// "1 1" 를 인쇄함

위와 같이 height, width에 1을 할당하게 되면 이는 property wrapper의 init 생성자를 호출하게 된다.

struct NarrowRectangle {
  @SmallNumber(wrappedValue: 2, maximum: 5) var height: Int
  @SmallNumber(wrappedValue: 3, maximum: 4) var width: Int
}

var narrowRectangle = NarrowRectangle()
print(narrowRectangle.height, narrowRectangle.width)
// "2 3" 를 인쇄함

narrowRectangle.height = 100
narrowRectangle.width = 100
print(narrowRectangle.height, narrowRectangle.width)
// "5 4" 를 인쇄함

property wrapper의 인수를 포함할 때 할당을 사용하여 초기값을 지정할 수 있다. height프로퍼티를 감싸는 SmallNumber 인스턴스는 SmallNumber(wrappedValue:1)을 호출하여 초기화 했고, width 프로퍼티를 감싸는 SmallNumber 인스턴스는 SmallNumber(wrappedValue:2, maximum:9)를 호출하여 초기화된다.

---

 

Global and Local Variables

앞에서 소개한 계산된 프로퍼티와 프로퍼티 옵저버 기능은 전역변수와 지역변수 모두에서 사용 가능하다. 전역변수(global)는 어떤 함수나, 메소드, 클로저 및 타입 밖에서 정의한 변수이다. 지역변수(local)은 함수나, 메소드 및 클로저 안에서 정의한 변수이다.

앞서 배운 모든 전역변수와 지역변수는 Stored Variable (저장된 변수) 였다. 이는 저장 프로퍼티와 비슷하게 값에게 저장공간을 주고 해당 값을 설정하고, 검색할 수 있게 해준다.

물론, 전역 범위와 지역 범위에서 Computed Variable를 정의하고 변수에 대한 옵저버를 정의할 수도 있다. Computed Variable은 값을 저장하지 않고 계산 프로퍼티와 같은 방식으로 쓰인다.

전역변수, 상수는 lazy 저장 프로퍼티와 동일한 방법으로 처리된다. 하지만 전역변수 및 상수에 lazy키워드를 표시할 필요는 없다.

이와 반대로 지역변수, 상수에는 절대로 lazy를 사용할 수 없다.

---

 

Type Properties

각각의 인스턴스가 아닌 타입 자체에 속하게 되는 프로퍼티를 타입 프로퍼티라고 한다.

이제까지 알아본 프로퍼티 개념은 모두 타입을 정의하고 그 타입의 인스턴스가 생성되었을때 사용될 수 있는 인스턴스 프로퍼티이다. 인스턴스 프로퍼티는 인스턴스를 새로 생성할 때 마다 초깃값에 해당하는 값이 프로퍼티의 값이 되고, 각 인스턴스마다 다른 값을 지닐 수 있다.

타입 프로퍼티는 타입 자체에 영향을 미치는 프로퍼티이고 인스턴스의 생성 여부와 상관없이 타입 프로퍼티의 값은 하나이다. 이 타입 프로퍼티는 특정 타입의 모든 인스턴스에 공통으로 사용되는 값을 정의할 때 유용하다.

 

Type Property Syntax

타입속성은 static 키워드로 정의한다. 클래스에서는 static과 class 이렇게 2가지 형태로 타입 프로퍼티를 선언할 수 있는데 두가지 경우의 차이는 서브클래스에서 overriding 가능 여부이다. class 로 선언된 프로퍼티는 서브클래스에서 override 가능하다.

struct SomeStructure {
  static var storedTypeProperty = "Some value."
  static var computedTypeProperty: Int {
    return 1
  }
}
enum SomeEnumeration {
  static var storedTypeProperty = "Some value."
  static var computedTypeProperty: Int {
    return 6
  }
}
class SomeClass {
  static var storedTypeProperty = "Some value."
  static var computedTypeProperty: Int {
    return 27
  }
  class var overrideableComputedTypeProperty: Int {
    return 107
  }
}

▶ Note

• 위의 연산 타입 프로퍼티 예시는 읽기전용이지만, 같은 문법으로 연산된 인스턴스의 타입 프로퍼티에서는 읽고 쓸 수 있는 프로퍼티로 사용 가능하다. (아래예시)

class Aclass {
    // 저장 타입 프로퍼티
    static var typeProperty: Int = 0
    
    var instanceProperty: Int = 0 {
        didSet {
            Aclass.typeProperty = instanceProperty + 100
        }
    }
    
    // 연산 타입 프로퍼티
    static var typeComputedProperty: Int {
        get {
            return typeProperty
        }
        
        set {
            typeProperty = newValue
        }
    }
}

• 추가설명
  • 저장&연산 프로퍼티 앞에 static 이란 키워드를 붙이면 저장(연산)타입 프로퍼티가 됨

 

Querying and Setting Type Properties

타입 프로퍼티는 그냥 인스턴스 속성과 같이 점 구문으로 조회하고 설정한다.

print(SomeStructure.storedTypeProperty)
// "Some value." 를 인쇄함
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
// "Another value." 를 인쇄함
print(SomeEnumeration.computedTypeProperty)
// "6" 을 인쇄함
print(SomeClass.computedTypeProperty)
// "27" 을 인쇄함

아래 오디오 채널의 볼륨을 조절하고 관리하는 구조체 예제를 살펴보자.

스위프트 공식문서 chap10. 프로퍼티

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

위 코드는 현재 오디오 최대 볼륨 크기는 타입프로퍼티 maxInputLevelForAllChannels로 관리하고, 그 값은 thresholdLevel로 상수로 정의돼 있어서 currentLevel을 설정할때 마다 (didSet) 채널별 볼륨이 최대 그 값을 넘지 못하도록 조정해주는 구조체이다.

 

이렇게 만든 오디오 체널 구조체를 이용해 좌우 두개의 오디오 채털을 생성할 수 있다.

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

이제 leftChannel에 7을 할당해보자.

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

그럼 채널에서 최대값으로 설정한 값을 넘어가는 11을 할당해보자.

rightChannel.currentLevel = 11
print(rightChannel.currentLevel)
// Prints "10"
print(AudioChannel.maxInputLevelForAllChannels)
// Prints "10"

최대값 10이 넘어가는 값을 할당하자, 11을 입력했지만 10으로 설정된 것을 볼 수 있다.