14. Property

Stored Property

저장 속성과 지연 저장 속성

Stored Properties

var name: Type = DefaultValue

⬆️ Variable Stored Property

let name: Type = DefaultValue

⬆️ Constant Stored Property

//class Person {
//    let name: String = "Ben"
//    var age: Int = 20
//}
struct Person {
    let name: String = "Ben"
    var age: Int = 20
}

Explicit Member Expression

instanceName.propertyName
instanceName.propertyName = NewValue

// 구조체 인스턴스를 상수로 선언하면 바디 안에있는 메서드들이 다 상수로 바뀐다

// 클래스 상수
//let p = Person()
//p.name
//p.age = 21

// 구조체 변수
var p = Person()
p.name
p.age = 21

Lazy Stored Properties

지연 호출

lazy var name: Type = DefaultValue

// lazy let 은 사용 불가
// lazt는 기본값이 있어야됨

struct Image {
    init() {
        print("new image")
    }
}

struct BlogPost {
    let title: String = "Title"
    let content: String = "Content"
    lazy var attachment: Image = Image()
    
    let date: Date = Date()
    
    lazy var formattedDate: String = {      // 클로저를 이용하여 초기화
        let f = DateFormatter()
        f.dateStyle = .long
        f.dateStyle = .medium
        return f.string(from: date)
    }()
}

// 초기화 하려면 구조체를 변수로 설정해야된다. 상수로 선언하면 초기화 x
var post = BlogPost()
post.attachment

Computed Property

Computed Properties

var name: Type {
	get {
    	statements
        return expr
    }
    set(name) {
    	statements
    }
}

class Person {
   var name: String
   var yearOfBirth: Int

   init(name: String, year: Int) {
      self.name = name
      self.yearOfBirth = year
   }
    
    var age: Int {
        // 읽기 전용 속성
//        get {
//            let calendar = Calendar.current
//            let now = Date()
//            let year = calendar.component(.year, from: now)
//            return year - yearOfBirth
//        }
        let calendar = Calendar.current
        let now = Date()
        let year = calendar.component(.year, from: now)
        return year - yearOfBirth
        
        
        // 쓰기 전용 속성
//        set {
//            let calendar = Calendar.current
//            let now = Date()
//            let year = calendar.component(.year, from: now)
//            yearOfBirth = year - newValue
//        }
    }
}


let p = Person(name: "Ben", year: 2001)
p.age

//p.age = 50
p.yearOfBirth


// get 블럭을 생략하고 set 블럭만 쓰는 것은 문법적으로 허용할 수 없음

Read-only Computed Properties

var name: Type {
	get {
    	statements
        return expr
    }
}

---

var name: Type {
    statements
    return expr
}

Property Observer

var name: Type = DefaultValue {
	willSet(name) {
    	statements
    }
    didSet(name) {
    	statements
    }
}

// 속성감지
// 변수에만 추가
// 반드시 두 블럭 중 하나는 사용해야 됨

class Size {
    var width = 0.0 {
        willSet {
            print(width, "=>", newValue)
        }
        didSet {
            print(oldValue, "=>", width)
        }
    }
}

let s = Size()
s.width = 123

// 정리할 때 찾아보기

TypeProperty

Stored Type Properties

static var name: Type = DefaultValue
// Variable Stored Type Propery
static let name: Type = DefaultValue
// Constant Stored Type Property

TypeName.propertyName

class Math {
    static let pi = 3.14
}

let m = Math()
//m.pi
// 처음 접근하는 시점에 초기화 된다.
Math.pi

Computed Type Properties

static var name: Type {
	get {
    	statements
        return expr
    }
    set(name) {
    	statements
    }
}

---

class var name: Type {
	get {
    	statements
        return expr
    }
    set(name) {
    	statements
    }
}

enum Weekday: Int {
    case sunday = 1, monday, tuesday, wednesday, thursday, friday, saturday
    
    static var today: Weekday {
        let cal = Calendar.current
        let today = Date()
        let weekday = cal.component(.weekday, from: today)
        
        return Weekday(rawValue: weekday)!
    }
}

Weekday.today

self & super

self

• self
• self.propertyName
• self.method()
• self[index]
• self.init(parameters)

---

super

• super.propertyName
• super.method()
• super[index]
• super.init(parameters)

---

self 속성은 구조체에서만 사용
super 속성은 class에서만 사용 (상속)