Основы Swift / 11.4. Свойства

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 rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// этот диапазон отражает целые числа 0, 1, 2 и
// rangeOfFourItems.firstValue = 6
// это выдаст ошибку, даже хотя firstValue - это переменное свойство

class DataImporter {
    /*
     DataImporter - это класс, который импортирует данные из внешнего источника.
     Примем, что класс требует нетривиального количества времени на инициализацию.
     */
    var filename = "data.txt"
    // DataImporter - это класс, который предоставит здесь функциональность по импорту
}

class DataManager {
    lazy var importer = DataImporter()
    var data = [String]()
    // класс DataManager предоставит здесь свою функциональность по управлению даннысми
}

let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")
// экземпляр DataImporter для свойства importer так и не был создан

print(manager.importer.filename)
// объект класса DataImporter для свойства importer теперь был создан
// Выведет "data.txt"

1. Point инкапсулирует координаты точки x и y.
2. Size инкапсулирует width и height.
3. Rect определяет прямоугольник с началом отсчёта в виде точки и размерами.

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

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

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"

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
// About to set totalSteps to 200
// Added 200 steps
stepCounter.totalSteps = 360
// About to set totalSteps to 360
// Added 160 steps
stepCounter.totalSteps = 896
// About to set totalSteps to 896
// Added 536 steps

func someFunction(_ x: inout Int) {
    x = 134
}

someFunction(&stepCounter.totalSteps)

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

print(SomeStructure.storedTypeProperty)
// Выводит "Some value."
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
// Выводит "Another value."
print(SomeEnumeration.computedTypeProperty)
// Выводит "6"
print(SomeClass.computedTypeProperty)
// Выводит "27»

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(leftChannel.currentLevel)
// Выведет "7"
print(AudioChannel.maxInputLevelForAllChannels)
// Выведет "7"

rightChannel.currentLevel = 11
print(rightChannel.currentLevel)
// Выведет "10"
print(AudioChannel.maxInputLevelForAllChannels)
// Выведет "10"